Lichen (annotate deducer.py in 8af95b034317)

#!/usr/bin/env python

paul@44

2

paul@44

3

"""

paul@44

4

Deduce types for usage observations.

Copyright (C) 2014, 2015, 2016 Paul Boddie <paul@boddie.org.uk>

This program is free software; you can redistribute it and/or modify it under

paul@44

9

the terms of the GNU General Public License as published by the Free Software

paul@44

10

Foundation; either version 3 of the License, or (at your option) any later

paul@44

11

version.

This program is distributed in the hope that it will be useful, but WITHOUT

paul@44

14

ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS

paul@44

15

FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more

paul@44

16

details.

You should have received a copy of the GNU General Public License along with

paul@44

19

this program.  If not, see <http://www.gnu.org/licenses/>.

paul@44

20

"""

from common import first, get_attrname_from_location, get_attrnames, \

paul@44

23

                   init_item, make_key, sorted_output, \

paul@44

24

                   CommonOutput

paul@44

25

from encoders import encode_attrnames, encode_access_location, \

paul@56

26

                     encode_constrained, encode_location, encode_usage, \

paul@67

27

                     get_kinds, test_for_kinds, test_for_type

paul@71

28

from errors import DeduceError

paul@44

29

from os.path import join

paul@57

30

from referencing import combine_types, is_single_class_type, separate_types, \

paul@57

31

                        Reference

class Deducer(CommonOutput):

    "Deduce types in a program."

    def __init__(self, importer, output):

"""

paul@44

40

        Initialise an instance using the given 'importer' that will perform

paul@44

41

        deductions on the program information, writing the results to the given

paul@44

42

        'output' directory.

paul@44

43

"""

        self.importer = importer

paul@44

46

        self.output = output

        # Descendants of classes.

        self.descendants = {}

paul@44

51

        self.init_descendants()

paul@44

52

        self.init_special_attributes()

        # Map locations to usage in order to determine specific types.

        self.location_index = {}

        # Map access locations to definition locations.

        self.access_index = {}

        # Map aliases to accesses that define them.

        self.alias_index = {}

        # Map constant accesses to redefined accesses.

        self.const_accesses = {}

paul@67

69

        self.const_accesses_rev = {}

        # Map usage observations to assigned attributes.

        self.assigned_attrs = {}

        # Map usage observations to objects.

        self.attr_class_types = {}

paul@44

78

        self.attr_instance_types = {}

paul@44

79

        self.attr_module_types = {}

        # Modified attributes from usage observations.

        self.modified_attributes = {}

        # Accesses that are assignments.

        self.reference_assignments = set()

        # Map locations to types, constrained indicators and attributes.

        self.accessor_class_types = {}

paul@44

92

        self.accessor_instance_types = {}

paul@44

93

        self.accessor_module_types = {}

paul@44

94

        self.provider_class_types = {}

paul@44

95

        self.provider_instance_types = {}

paul@44

96

        self.provider_module_types = {}

paul@67

97

        self.accessor_constrained = set()

paul@44

98

        self.access_constrained = set()

paul@44

99

        self.referenced_attrs = {}

paul@44

100

        self.referenced_objects = {}

        # Details of access operations.

        self.access_plans = {}

        # Accumulated information about accessors and providers.

        self.accessor_general_class_types = {}

paul@44

109

        self.accessor_general_instance_types = {}

paul@44

110

        self.accessor_general_module_types = {}

paul@44

111

        self.accessor_all_types = {}

paul@44

112

        self.accessor_all_general_types = {}

paul@44

113

        self.provider_all_types = {}

paul@44

114

        self.accessor_guard_tests = {}

        # Accumulated information about accessed attributes and

paul@67

117

        # access/attribute-specific accessor tests.

        self.reference_all_attrs = {}

paul@44

120

        self.reference_all_attrtypes = {}

paul@67

121

        self.reference_all_accessor_types = {}

paul@67

122

        self.reference_all_accessor_general_types = {}

paul@44

123

        self.reference_test_types = {}

paul@44

124

        self.reference_test_accessor_types = {}

        # The processing workflow itself.

        self.init_usage_index()

paul@44

129

        self.init_accessors()

paul@44

130

        self.init_accesses()

paul@44

131

        self.init_aliases()

paul@44

132

        self.init_attr_type_indexes()

paul@44

133

        self.modify_mutated_attributes()

paul@44

134

        self.identify_references()

paul@44

135

        self.classify_accessors()

paul@44

136

        self.classify_accesses()

paul@67

137

        self.initialise_access_plans()

    def to_output(self):

        "Write the output files using deduction information."

        self.check_output()

        self.write_mutations()

paul@44

146

        self.write_accessors()

paul@44

147

        self.write_accesses()

paul@65

148

        self.write_access_plans()

    def write_mutations(self):

"""

paul@44

153

        Write mutation-related output in the following format:

        qualified name " " original object type

        Object type can be "<class>", "<function>" or "<var>".

paul@44

158

"""

        f = open(join(self.output, "mutations"), "w")

paul@44

161

        try:

paul@44

162

            attrs = self.modified_attributes.items()

paul@44

163

            attrs.sort()

            for attr, value in attrs:

paul@44

166

                print >>f, attr, value

paul@44

167

        finally:

paul@44

168

            f.close()

    def write_accessors(self):

"""

paul@44

173

        Write reference-related output in the following format for types:

        location " " ( "constrained" | "deduced" ) " " attribute type " " most general type names " " number of specific types

        Note that multiple lines can be given for each location, one for each

paul@44

178

        attribute type.

        Locations have the following format:

        qualified name of scope "." local name ":" name version

        The attribute type can be "<class>", "<instance>", "<module>" or "<>",

paul@44

185

        where the latter indicates an absence of suitable references.

        Type names indicate the type providing the attributes, being either a

paul@44

188

        class or module qualified name.

        ----

        A summary of accessor types is formatted as follows:

        location " " ( "constrained" | "deduced" ) " " ( "specific" | "common" | "unguarded" ) " " most general type names " " number of specific types

        This summary groups all attribute types (class, instance, module) into a

paul@44

197

        single line in order to determine the complexity of identifying an

paul@44

198

        accessor.

        ----

        References that cannot be supported by any types are written to a

paul@44

203

        warnings file in the following format:

        location

        ----

        For each location where a guard would be asserted to guarantee the

paul@44

210

        nature of an object, the following format is employed:

        location " " ( "specific" | "common" ) " " object kind " " object types

        Object kind can be "<class>", "<instance>" or "<module>".

paul@44

215

"""

        f_type_summary = open(join(self.output, "type_summary"), "w")

paul@44

218

        f_types = open(join(self.output, "types"), "w")

paul@44

219

        f_warnings = open(join(self.output, "type_warnings"), "w")

paul@44

220

        f_guards = open(join(self.output, "guards"), "w")

        try:

paul@44

223

            locations = self.accessor_class_types.keys()

paul@44

224

            locations.sort()

            for location in locations:

paul@67

227

                constrained = location in self.accessor_constrained

                # Accessor information.

                class_types = self.accessor_class_types[location]

paul@44

232

                instance_types = self.accessor_instance_types[location]

paul@44

233

                module_types = self.accessor_module_types[location]

                general_class_types = self.accessor_general_class_types[location]

paul@44

236

                general_instance_types = self.accessor_general_instance_types[location]

paul@44

237

                general_module_types = self.accessor_general_module_types[location]

                all_types = self.accessor_all_types[location]

paul@44

240

                all_general_types = self.accessor_all_general_types[location]

                if class_types:

paul@44

243

                    print >>f_types, encode_location(location), encode_constrained(constrained), "<class>", \

paul@44

244

                        sorted_output(general_class_types), len(class_types)

                if instance_types:

paul@44

247

                    print >>f_types, encode_location(location), encode_constrained(constrained), "<instance>", \

paul@44

248

                        sorted_output(general_instance_types), len(instance_types)

                if module_types:

paul@44

251

                    print >>f_types, encode_location(location), encode_constrained(constrained), "<module>", \

paul@44

252

                        sorted_output(general_module_types), len(module_types)

                if not all_types:

paul@44

255

                    print >>f_types, encode_location(location), "deduced", "<>", 0

paul@55

256

                    attrnames = list(self.location_index[location])

paul@55

257

                    attrnames.sort()

paul@55

258

                    print >>f_warnings, encode_location(location), "; ".join(map(encode_usage, attrnames))

                guard_test = self.accessor_guard_tests.get(location)

                # Write specific type guard details.

                if guard_test and guard_test.startswith("specific"):

paul@44

265

                    print >>f_guards, encode_location(location), guard_test, \

paul@56

266

                        get_kinds(all_types)[0], \

paul@44

267

                        sorted_output(all_types)

                # Write common type guard details.

                elif guard_test and guard_test.startswith("common"):

paul@44

272

                    print >>f_guards, encode_location(location), guard_test, \

paul@56

273

                        get_kinds(all_general_types)[0], \

paul@44

274

                        sorted_output(all_general_types)

                print >>f_type_summary, encode_location(location), encode_constrained(constrained), \

paul@44

277

                    guard_test or "unguarded", sorted_output(all_general_types), len(all_types)

        finally:

paul@44

280

            f_type_summary.close()

paul@44

281

            f_types.close()

paul@44

282

            f_warnings.close()

paul@44

283

            f_guards.close()

    def write_accesses(self):

"""

paul@44

288

        Specific attribute output is produced in the following format:

        location " " ( "constrained" | "deduced" ) " " attribute type " " attribute references

        Note that multiple lines can be given for each location and attribute

paul@44

293

        name, one for each attribute type.

        Locations have the following format:

        qualified name of scope "." local name " " attribute name ":" access number

        The attribute type can be "<class>", "<instance>", "<module>" or "<>",

paul@44

300

        where the latter indicates an absence of suitable references.

        Attribute references have the following format:

        object type ":" qualified name

        Object type can be "<class>", "<function>" or "<var>".

        ----

        A summary of attributes is formatted as follows:

        location " " attribute name " " ( "constrained" | "deduced" ) " " test " " attribute references

        This summary groups all attribute types (class, instance, module) into a

paul@44

315

        single line in order to determine the complexity of each access.

        Tests can be "validate", "specific", "untested", "guarded-validate" or "guarded-specific".

        ----

        For each access where a test would be asserted to guarantee the

paul@44

322

        nature of an attribute, the following formats are employed:

        location " " attribute name " " "validate"

paul@44

325

        location " " attribute name " " "specific" " " attribute type " " object type

        ----

        References that cannot be supported by any types are written to a

paul@44

330

        warnings file in the following format:

        location

paul@44

333

"""

        f_attr_summary = open(join(self.output, "attribute_summary"), "w")

paul@44

336

        f_attrs = open(join(self.output, "attributes"), "w")

paul@44

337

        f_tests = open(join(self.output, "tests"), "w")

paul@44

338

        f_warnings = open(join(self.output, "attribute_warnings"), "w")

        try:

paul@44

341

            locations = self.referenced_attrs.keys()

paul@44

342

            locations.sort()

            for location in locations:

paul@44

345

                constrained = location in self.access_constrained

                # Attribute information, both name-based and anonymous.

                referenced_attrs = self.referenced_attrs[location]

                if referenced_attrs:

paul@44

352

                    attrname = get_attrname_from_location(location)

                    all_accessed_attrs = self.reference_all_attrs[location]

                    for attrtype, attrs in self.get_referenced_attrs(location):

paul@44

357

                        print >>f_attrs, encode_access_location(location), encode_constrained(constrained), attrtype, sorted_output(attrs)

                    test_type = self.reference_test_types.get(location)

                    # Write the need to test at run time.

                    if test_type == "validate":

paul@44

364

                        print >>f_tests, encode_access_location(location), test_type

                    # Write any type checks for anonymous accesses.

                    elif test_type and self.reference_test_accessor_types.get(location):

paul@44

369

                        print >>f_tests, encode_access_location(location), test_type, \

paul@44

370

                            sorted_output(all_accessed_attrs), \

paul@44

371

                            self.reference_test_accessor_types[location]

                    print >>f_attr_summary, encode_access_location(location), encode_constrained(constrained), \

paul@44

374

                        test_type or "untested", sorted_output(all_accessed_attrs)

                else:

paul@44

377

                    print >>f_warnings, encode_access_location(location)

        finally:

paul@44

380

            f_attr_summary.close()

paul@44

381

            f_attrs.close()

paul@44

382

            f_tests.close()

paul@44

383

            f_warnings.close()

    def write_access_plans(self):

        "Each attribute access is written out as a plan."

        f_attrs = open(join(self.output, "attribute_plans"), "w")

        try:

paul@67

392

            locations = self.access_plans.keys()

paul@67

393

            locations.sort()

            for location in locations:

paul@67

396

                base, traversed, attrnames, method, test, attr = self.access_plans[location]

paul@67

397

                print >>f_attrs, encode_access_location(location), base, \

paul@67

398

                                 ".".join(traversed) or "{}", \

paul@67

399

                                 ".".join(attrnames) or "{}", \

paul@67

400

                                 method, test, \

paul@67

401

                                 attr or "{}"

        finally:

paul@67

404

            f_attrs.close()

    def classify_accessors(self):

        "For each program location, classify accessors."

        # Where instance and module types are defined, class types are also

paul@44

411

        # defined. See: init_definition_details

        locations = self.accessor_class_types.keys()

        for location in locations:

paul@67

416

            constrained = location in self.accessor_constrained

            # Provider information.

            class_types = self.provider_class_types[location]

paul@44

421

            instance_types = self.provider_instance_types[location]

paul@44

422

            module_types = self.provider_module_types[location]

            # Collect specific and general type information.

            self.provider_all_types[location] = \

paul@57

427

                combine_types(class_types, instance_types, module_types)

            # Accessor information.

            class_types = self.accessor_class_types[location]

paul@44

432

            self.accessor_general_class_types[location] = \

paul@69

433

                general_class_types = self.get_most_general_class_types(class_types)

            instance_types = self.accessor_instance_types[location]

paul@44

436

            self.accessor_general_instance_types[location] = \

paul@69

437

                general_instance_types = self.get_most_general_class_types(instance_types)

            module_types = self.accessor_module_types[location]

paul@44

440

            self.accessor_general_module_types[location] = \

paul@44

441

                general_module_types = self.get_most_general_module_types(module_types)

            # Collect specific and general type information.

            self.accessor_all_types[location] = all_types = \

paul@57

446

                combine_types(class_types, instance_types, module_types)

            self.accessor_all_general_types[location] = all_general_types = \

paul@57

449

                combine_types(general_class_types, general_instance_types, general_module_types)

            # Record guard information.

            if not constrained:

                # Record specific type guard details.

                if len(all_types) == 1:

paul@67

458

                    self.accessor_guard_tests[location] = test_for_type("specific", first(all_types))

paul@57

459

                elif is_single_class_type(all_types):

paul@44

460

                    self.accessor_guard_tests[location] = "specific-object"

                # Record common type guard details.

                elif len(all_general_types) == 1:

paul@67

465

                    self.accessor_guard_tests[location] = test_for_type("common", first(all_types))

paul@57

466

                elif is_single_class_type(all_general_types):

paul@44

467

                    self.accessor_guard_tests[location] = "common-object"

                # Otherwise, no convenient guard can be defined.

    def classify_accesses(self):

        "For each program location, classify accesses."

        # Attribute accesses use potentially different locations to those of

paul@44

476

        # accessors.

        locations = self.referenced_attrs.keys()

        for location in locations:

paul@44

481

            constrained = location in self.access_constrained

            # Combine type information from all accessors supplying the access.

            accessor_locations = self.get_accessors_for_access(location)

            all_provider_types = set()

paul@44

488

            all_accessor_types = set()

paul@44

489

            all_accessor_general_types = set()

            for accessor_location in accessor_locations:

                # Obtain the provider types for guard-related attribute access

paul@44

494

                # checks.

                all_provider_types.update(self.provider_all_types.get(accessor_location))

                # Obtain the accessor guard types (specific and general).

                all_accessor_types.update(self.accessor_all_types.get(accessor_location))

paul@67

501

                all_accessor_general_types.update(self.accessor_all_general_types.get(accessor_location))

            # Obtain basic properties of the types involved in the access.

            single_accessor_type = len(all_accessor_types) == 1

paul@70

506

            single_accessor_class_type = is_single_class_type(all_accessor_types)

paul@70

507

            single_accessor_general_type = len(all_accessor_general_types) == 1

paul@70

508

            single_accessor_general_class_type = is_single_class_type(all_accessor_general_types)

            # Determine whether the attribute access is guarded or not.

            guarded = (

paul@70

513

                single_accessor_type or single_accessor_class_type or

paul@70

514

                single_accessor_general_type or single_accessor_general_class_type

            if guarded:

paul@44

518

                (guard_class_types, guard_instance_types, guard_module_types,

paul@57

519

                    _function_types, _var_types) = separate_types(all_provider_types)

            self.reference_all_accessor_types[location] = all_accessor_types

paul@67

522

            self.reference_all_accessor_general_types[location] = all_accessor_general_types

            # Attribute information, both name-based and anonymous.

            referenced_attrs = self.referenced_attrs[location]

            if not referenced_attrs:

paul@71

529

                raise DeduceError, location

            # Record attribute information for each name used on the

paul@71

532

            # accessor.

            attrname = get_attrname_from_location(location)

            all_accessed_attrs = set()

paul@71

537

            all_providers = set()

            # Obtain provider and attribute details for this kind of

paul@71

540

            # object.

            for attrtype, object_type, attr in referenced_attrs:

paul@71

543

                all_accessed_attrs.add(attr)

paul@71

544

                all_providers.add(object_type)

            all_general_providers = self.get_most_general_types(all_providers)

            # Determine which attributes would be provided by the

paul@71

549

            # accessor types upheld by a guard.

            if guarded:

paul@71

552

                guard_attrs = set()

paul@71

553

                for _attrtype, object_type, attr in \

paul@71

554

                    self._identify_reference_attribute(attrname, guard_class_types, guard_instance_types, guard_module_types):

paul@71

555

                    guard_attrs.add(attr)

paul@71

556

            else:

paul@71

557

                guard_attrs = None

            self.reference_all_attrs[location] = all_accessed_attrs

            # Constrained accesses guarantee the nature of the accessor.

paul@71

562

            # However, there may still be many types involved.

            if constrained:

paul@71

565

                if single_accessor_type:

paul@71

566

                    self.reference_test_types[location] = test_for_type("constrained-specific", first(all_accessor_types))

paul@71

567

                elif single_accessor_class_type:

paul@71

568

                    self.reference_test_types[location] = "constrained-specific-object"

paul@71

569

                elif single_accessor_general_type:

paul@71

570

                    self.reference_test_types[location] = test_for_type("constrained-common", first(all_accessor_general_types))

paul@71

571

                elif single_accessor_general_class_type:

paul@71

572

                    self.reference_test_types[location] = "constrained-common-object"

paul@44

573

                else:

paul@71

574

                    self.reference_test_types[location] = "constrained-many"

            # Suitably guarded accesses, where the nature of the

paul@71

577

            # accessor can be guaranteed, do not require the attribute

paul@71

578

            # involved to be validated. Otherwise, for unguarded

paul@71

579

            # accesses, access-level tests are required.

            elif guarded and all_accessed_attrs.issubset(guard_attrs):

paul@71

582

                if single_accessor_type:

paul@71

583

                    self.reference_test_types[location] = test_for_type("guarded-specific", first(all_accessor_types))

paul@71

584

                elif single_accessor_class_type:

paul@71

585

                    self.reference_test_types[location] = "guarded-specific-object"

paul@71

586

                elif single_accessor_general_type:

paul@71

587

                    self.reference_test_types[location] = test_for_type("guarded-common", first(all_accessor_general_types))

paul@71

588

                elif single_accessor_general_class_type:

paul@71

589

                    self.reference_test_types[location] = "guarded-common-object"

            # Record the need to test the type of anonymous and

paul@71

592

            # unconstrained accessors.

            elif len(all_providers) == 1:

paul@71

595

                provider = first(all_providers)

paul@71

596

                if provider != '__builtins__.object':

paul@71

597

                    all_accessor_kinds = set(get_kinds(all_accessor_types))

paul@71

598

                    if len(all_accessor_kinds) == 1:

paul@71

599

                        test_type = test_for_kinds("specific", all_accessor_kinds)

paul@70

600

                    else:

paul@71

601

                        test_type = "specific-object"

paul@71

602

                    self.reference_test_types[location] = test_type

paul@71

603

                    self.reference_test_accessor_types[location] = provider

            elif len(all_general_providers) == 1:

paul@71

606

                provider = first(all_general_providers)

paul@71

607

                if provider != '__builtins__.object':

paul@71

608

                    all_accessor_kinds = set(get_kinds(all_accessor_general_types))

paul@71

609

                    if len(all_accessor_kinds) == 1:

paul@71

610

                        test_type = test_for_kinds("common", all_accessor_kinds)

paul@71

611

                    else:

paul@71

612

                        test_type = "common-object"

paul@71

613

                    self.reference_test_types[location] = test_type

paul@71

614

                    self.reference_test_accessor_types[location] = provider

            # Record the need to test the identity of the attribute.

            else:

paul@71

619

                self.reference_test_types[location] = "validate"

    def initialise_access_plans(self):

        "Define attribute access plans."

        for location in self.referenced_attrs.keys():

paul@67

626

            self.access_plans[location] = self.get_access_plan(location)

    def get_referenced_attrs(self, location):

"""

paul@44

631

        Return attributes referenced at the given access 'location' by the given

paul@44

632

        'attrname' as a list of (attribute type, attribute set) tuples.

paul@44

633

"""

        d = {}

paul@69

636

        for attrtype, objtype, attr in self.referenced_attrs[location]:

paul@69

637

            init_item(d, attrtype, set)

paul@69

638

            d[attrtype].add(attr)

paul@69

639

        l = d.items()

paul@69

640

        l.sort() # class, module, instance

paul@44

641

        return l

    # Initialisation methods.

    def init_descendants(self):

        "Identify descendants of each class."

        for name in self.importer.classes.keys():

paul@44

650

            self.get_descendants_for_class(name)

    def get_descendants_for_class(self, name):

"""

paul@44

655

        Use subclass information to deduce the descendants for the class of the

paul@44

656

        given 'name'.

paul@44

657

"""

        if not self.descendants.has_key(name):

paul@44

660

            descendants = set()

            for subclass in self.importer.subclasses[name]:

paul@44

663

                descendants.update(self.get_descendants_for_class(subclass))

paul@44

664

                descendants.add(subclass)

            self.descendants[name] = descendants

        return self.descendants[name]

    def init_special_attributes(self):

        "Add special attributes to the classes for inheritance-related tests."

        all_class_attrs = self.importer.all_class_attrs

        for name, descendants in self.descendants.items():

paul@44

677

            for descendant in descendants:

paul@44

678

                all_class_attrs[descendant]["#%s" % name] = name

        for name in all_class_attrs.keys():

paul@44

681

            all_class_attrs[name]["#%s" % name] = name

    def init_usage_index(self):

"""

paul@44

686

        Create indexes for module and function attribute usage and for anonymous

paul@44

687

        accesses.

paul@44

688

"""

        for module in self.importer.get_modules():

paul@44

691

            for path, assignments in module.attr_usage.items():

paul@44

692

                self.add_usage(assignments, path)

        for location, all_attrnames in self.importer.all_attr_accesses.items():

paul@44

695

            for attrnames in all_attrnames:

paul@44

696

                attrname = get_attrnames(attrnames)[-1]

paul@44

697

                access_location = (location, None, attrnames, 0)

paul@44

698

                self.add_usage_term(access_location, [attrname])

    def add_usage(self, assignments, path):

"""

paul@44

703

        Collect usage from the given 'assignments', adding 'path' details to

paul@44

704

        each record if specified. Add the usage to an index mapping to location

paul@44

705

        information, as well as to an index mapping locations to usages.

paul@44

706

"""

        for name, versions in assignments.items():

paul@44

709

            for i, usages in enumerate(versions):

paul@44

710

                location = (path, name, None, i)

                for attrnames in usages:

paul@44

713

                    self.add_usage_term(location, attrnames)

    def add_usage_term(self, location, attrnames):

"""

paul@44

718

        For 'location' and using 'attrnames' as a description of usage, record

paul@44

719

        in the usage index a mapping from the usage to 'location', and record in

paul@44

720

        the location index a mapping from 'location' to the usage.

paul@44

721

"""

        key = make_key(attrnames)

        init_item(self.location_index, location, set)

paul@44

726

        self.location_index[location].add(key)

    def init_accessors(self):

        "Create indexes for module and function accessor information."

        for module in self.importer.get_modules():

paul@44

733

            for path, all_accesses in module.attr_accessors.items():

paul@44

734

                self.add_accessors(all_accesses, path)

    def add_accessors(self, all_accesses, path):

"""

paul@44

739

        For attribute accesses described by the mapping of 'all_accesses' from

paul@44

740

        name details to accessor details, record the locations of the accessors

paul@44

741

        for each access.

paul@44

742

"""

        # Get details for each access combining the given name and attribute.

        for (name, attrnames), accesses in all_accesses.items():

            # Obtain the usage details using the access information.

            for access_number, versions in enumerate(accesses):

paul@44

751

                access_location = (path, name, attrnames, access_number)

paul@44

752

                locations = []

                for version in versions:

paul@44

755

                    location = (path, name, None, version)

paul@44

756

                    locations.append(location)

                self.access_index[access_location] = locations

    def get_accessors_for_access(self, access_location):

        "Find a definition providing accessor details, if necessary."

        try:

paul@44

765

            return self.access_index[access_location]

paul@44

766

        except KeyError:

paul@44

767

            return [access_location]

    def init_accesses(self):

"""

paul@44

772

        Initialise collections for accesses involving assignments.

paul@44

773

"""

        # For each scope, obtain access details.

        for path, all_accesses in self.importer.all_attr_access_modifiers.items():

            # For each combination of name and attribute names, obtain

paul@44

780

            # applicable modifiers.

            for (name, attrnames), modifiers in all_accesses.items():

                # For each access, determine the name versions affected by

paul@44

785

                # assignments.

                for access_number, assignment in enumerate(modifiers):

paul@44

788

                    if name:

paul@44

789

                        access_location = (path, name, attrnames, access_number)

paul@44

790

                    else:

paul@44

791

                        access_location = (path, None, attrnames, 0)

                    if assignment:

paul@71

794

                        self.reference_assignments.add(access_location)

                    # Associate assignments with usage.

                    accessor_locations = self.get_accessors_for_access(access_location)

                    for location in accessor_locations:

paul@44

801

                        for usage in self.location_index[location]:

paul@44

802

                            key = make_key(usage)

                            if assignment:

paul@44

805

                                init_item(self.assigned_attrs, key, set)

paul@44

806

                                self.assigned_attrs[key].add((path, name, attrnames))

    def init_aliases(self):

        "Expand aliases so that alias-based accesses can be resolved."

        # Get aliased names with details of their accesses.

        for name_path, all_aliases in self.importer.all_aliased_names.items():

paul@44

815

            path, name = name_path.rsplit(".", 1)

            # For each version of the name, obtain the access location.

            for version, (original_name, attrnames, access_number) in all_aliases.items():

paul@44

820

                accessor_location = (path, name, None, version)

paul@44

821

                access_location = (path, original_name, attrnames, access_number)

paul@44

822

                init_item(self.alias_index, accessor_location, list)

paul@44

823

                self.alias_index[accessor_location].append(access_location)

        # Get aliases in terms of non-aliases and accesses.

        for accessor_location, access_locations in self.alias_index.items():

paul@44

828

            self.update_aliases(accessor_location, access_locations)

    def update_aliases(self, accessor_location, access_locations, visited=None):

"""

paul@44

833

        Update the given 'accessor_location' defining an alias, update

paul@44

834

        'access_locations' to refer to non-aliases, following name references

paul@44

835

        via the access index.

        If 'visited' is specified, it contains a set of accessor locations (and

paul@44

838

        thus keys to the alias index) that are currently being defined.

paul@44

839

"""

        if visited is None:

paul@44

842

            visited = set()

        updated_locations = set()

        for access_location in access_locations:

paul@44

847

            (path, original_name, attrnames, access_number) = access_location

            # Where an alias refers to a name access, obtain the original name

paul@44

850

            # version details.

            if attrnames is None:

                # For each name version, attempt to determine any accesses that

paul@44

855

                # initialise the name.

                for name_accessor_location in self.access_index[access_location]:

                    # Already-visited aliases do not contribute details.

                    if name_accessor_location in visited:

paul@44

862

                        continue

                    visited.add(name_accessor_location)

                    name_access_locations = self.alias_index.get(name_accessor_location)

paul@44

867

                    if name_access_locations:

paul@44

868

                        updated_locations.update(self.update_aliases(name_accessor_location, name_access_locations, visited))

paul@44

869

                    else:

paul@44

870

                        updated_locations.add(name_accessor_location)

            # Otherwise, record the access details.

            else:

paul@44

875

                updated_locations.add(access_location)

        self.alias_index[accessor_location] = updated_locations

paul@44

878

        return updated_locations

    # Attribute mutation for types.

    def modify_mutated_attributes(self):

        "Identify known, mutated attributes and change their state."

        # Usage-based accesses.

        for usage, all_attrnames in self.assigned_attrs.items():

paul@44

889

            if not usage:

paul@44

890

                continue

            for path, name, attrnames in all_attrnames:

paul@44

893

                class_types = self.get_class_types_for_usage(usage)

paul@44

894

                only_instance_types = set(self.get_instance_types_for_usage(usage)).difference(class_types)

paul@44

895

                module_types = self.get_module_types_for_usage(usage)

                # Detect self usage within methods in order to narrow the scope

paul@44

898

                # of the mutation.

                t = name == "self" and self.constrain_self_reference(path, class_types, only_instance_types)

paul@44

901

                if t:

paul@44

902

                    class_types, only_instance_types, module_types, constrained = t

paul@44

903

                objects = set(class_types).union(only_instance_types).union(module_types)

                self.mutate_attribute(objects, attrnames)

    def mutate_attribute(self, objects, attrnames):

        "Mutate static 'objects' with the given 'attrnames'."

        for name in objects:

paul@44

912

            attr = "%s.%s" % (name, attrnames)

paul@44

913

            value = self.importer.get_object(attr)

            # If the value is None, the attribute is

paul@44

916

            # inherited and need not be set explicitly on

paul@44

917

            # the class concerned.

            if value:

paul@44

920

                self.modified_attributes[attr] = value

paul@44

921

                self.importer.set_object(attr, value.as_var())

    # Simplification of types.

    def get_most_general_types(self, types):

        "Return the most general types for the given 'types'."

        module_types = set()

paul@69

930

        class_types = set()

        for type in types:

paul@69

933

            ref = self.importer.identify(type)

paul@69

934

            if ref.has_kind("<module>"):

paul@69

935

                module_types.add(type)

paul@69

936

            else:

paul@69

937

                class_types.add(type)

        types = set(self.get_most_general_module_types(module_types))

paul@69

940

        types.update(self.get_most_general_class_types(class_types))

paul@69

941

        return types

    def get_most_general_class_types(self, class_types):

        "Return the most general types for the given 'class_types'."

        class_types = set(class_types)

paul@44

948

        to_remove = set()

        for class_type in class_types:

paul@44

951

            for base in self.importer.classes[class_type]:

paul@44

952

                base = base.get_origin()

paul@44

953

                descendants = self.descendants[base]

paul@44

954

                if base in class_types and descendants.issubset(class_types):

paul@44

955

                    to_remove.update(descendants)

        class_types.difference_update(to_remove)

paul@44

958

        return class_types

    def get_most_general_module_types(self, module_types):

        "Return the most general type for the given 'module_types'."

        # Where all modules are provided, an object would provide the same

paul@44

965

        # attributes.

        if len(module_types) == len(self.importer.modules):

paul@44

968

            return ["__builtins__.object"]

paul@44

969

        else:

paul@44

970

            return module_types

    # Type deduction for usage.

    def get_types_for_usage(self, attrnames, objects):

"""

paul@44

977

        Identify the types that can support the given 'attrnames', using the

paul@44

978

        given 'objects' as the catalogue of type details.

paul@44

979

"""

        types = []

paul@44

982

        for name, _attrnames in objects.items():

paul@44

983

            if set(attrnames).issubset(_attrnames):

paul@44

984

                types.append(name)

paul@44

985

        return types

    # More efficient usage-to-type indexing and retrieval.

    def init_attr_type_indexes(self):

        "Identify the types that can support each attribute name."

        self._init_attr_type_index(self.attr_class_types, self.importer.all_class_attrs)

paul@44

994

        self._init_attr_type_index(self.attr_instance_types, self.importer.all_combined_attrs)

paul@44

995

        self._init_attr_type_index(self.attr_module_types, self.importer.all_module_attrs)

    def _init_attr_type_index(self, attr_types, attrs):

"""

paul@44

1000

        Initialise the 'attr_types' attribute-to-types mapping using the given

paul@44

1001

        'attrs' type-to-attributes mapping.

paul@44

1002

"""

        for name, attrnames in attrs.items():

paul@44

1005

            for attrname in attrnames:

paul@44

1006

                init_item(attr_types, attrname, set)

paul@44

1007

                attr_types[attrname].add(name)

    def get_class_types_for_usage(self, attrnames):

        "Return names of classes supporting the given 'attrnames'."

        return self._get_types_for_usage(attrnames, self.attr_class_types, self.importer.all_class_attrs)

    def get_instance_types_for_usage(self, attrnames):

"""

paul@44

1018

        Return names of classes whose instances support the given 'attrnames'

paul@44

1019

        (as either class or instance attributes).

paul@44

1020

"""

        return self._get_types_for_usage(attrnames, self.attr_instance_types, self.importer.all_combined_attrs)

    def get_module_types_for_usage(self, attrnames):

        "Return names of modules supporting the given 'attrnames'."

        return self._get_types_for_usage(attrnames, self.attr_module_types, self.importer.all_module_attrs)

    def _get_types_for_usage(self, attrnames, attr_types, attrs):

"""

paul@44

1033

        For the given 'attrnames' representing attribute usage, return types

paul@44

1034

        recorded in the 'attr_types' attribute-to-types mapping that support

paul@44

1035

        such usage, with the given 'attrs' type-to-attributes mapping used to

paul@44

1036

        quickly assess whether a type supports all of the stated attributes.

paul@44

1037

"""

        # Where no attributes are used, any type would be acceptable.

        if not attrnames:

paul@44

1042

            return attrs.keys()

        types = []

        # Obtain types supporting the first attribute name...

        for name in attr_types.get(attrnames[0]) or []:

            # Record types that support all of the other attributes as well.

            _attrnames = attrs[name]

paul@44

1053

            if set(attrnames).issubset(_attrnames):

paul@44

1054

                types.append(name)

        return types

    # Reference identification.

    def identify_references(self):

        "Identify references using usage and name reference information."

        # Names with associated attribute usage.

        for location, usages in self.location_index.items():

            # Obtain attribute usage associated with a name, deducing the nature

paul@44

1069

            # of the name. Obtain types only for branches involving attribute

paul@44

1070

            # usage. (In the absence of usage, any type could be involved, but

paul@44

1071

            # then no accesses exist to require knowledge of the type.)

            have_usage = False

paul@44

1074

            have_no_usage_branch = False

            for usage in usages:

paul@44

1077

                if not usage:

paul@44

1078

                    have_no_usage_branch = True

paul@44

1079

                    continue

paul@44

1080

                elif not have_usage:

paul@44

1081

                    self.init_definition_details(location)

paul@44

1082

                    have_usage = True

paul@44

1083

                self.record_types_for_usage(location, usage)

            # Where some usage occurs, but where branches without usage also

paul@44

1086

            # occur, record the types for those branches anyway.

            if have_usage and have_no_usage_branch:

paul@44

1089

                self.init_definition_details(location)

paul@44

1090

                self.record_types_for_usage(location, None)

        # Specific name-based attribute accesses.

        alias_accesses = set()

        for access_location, accessor_locations in self.access_index.items():

paul@44

1097

            self.record_types_for_access(access_location, accessor_locations, alias_accesses)

        # Anonymous references with attribute chains.

        for location, accesses in self.importer.all_attr_accesses.items():

            # Get distinct attribute names.

            all_attrnames = set()

            for attrnames in accesses:

paul@44

1108

                all_attrnames.update(get_attrnames(attrnames))

            # Get attribute and accessor details for each attribute name.

            for attrname in all_attrnames:

paul@44

1113

                access_location = (location, None, attrname, 0)

paul@44

1114

                self.record_types_for_attribute(access_location, attrname)

        # References via constant/identified objects.

        for location, name_accesses in self.importer.all_const_accesses.items():

            # A mapping from the original name and attributes to resolved access

paul@44

1121

            # details.

            for original_access, access in name_accesses.items():

paul@44

1124

                original_name, original_attrnames = original_access

paul@44

1125

                objpath, ref, attrnames = access

                # Build an accessor combining the name and attribute names used.

                original_accessor = tuple([original_name] + original_attrnames.split("."))

                # Direct accesses to attributes.

                if not attrnames:

                    # Build a descriptive location based on the original

paul@44

1136

                    # details, exposing the final attribute name.

                    oa, attrname = original_accessor[:-1], original_accessor[-1]

paul@44

1139

                    oa = ".".join(oa)

                    access_location = (location, oa, attrname, 0)

paul@44

1142

                    accessor_location = (location, oa, None, 0)

paul@44

1143

                    self.access_index[access_location] = [accessor_location]

                    self.init_access_details(access_location)

paul@44

1146

                    self.init_definition_details(accessor_location)

                    # Obtain a reference for the accessor in order to properly

paul@44

1149

                    # determine its type.

                    if ref.get_kind() != "<instance>":

paul@44

1152

                        objpath = ref.get_origin()

                    objpath = objpath.rsplit(".", 1)[0]

                    # Where the object name conflicts with the module

paul@44

1157

                    # providing it, obtain the module details.

                    if objpath in self.importer.modules:

paul@44

1160

                        accessor = Reference("<module>", objpath)

paul@44

1161

                    else:

paul@44

1162

                        accessor = self.importer.get_object(objpath)

                    self.referenced_attrs[access_location] = [(accessor.get_kind(), accessor.get_origin(), ref)]

paul@44

1165

                    self.access_constrained.add(access_location)

                    class_types, instance_types, module_types = accessor.get_types()

paul@44

1168

                    self.record_reference_types(accessor_location, class_types, instance_types, module_types, True, True)

                else:

                    # Build a descriptive location based on the original

paul@64

1173

                    # details, employing the first remaining attribute name.

                    l = get_attrnames(attrnames)

paul@64

1176

                    attrname = l[0]

                    oa = original_accessor[:-len(l)]

paul@64

1179

                    oa = ".".join(oa)

                    access_location = (location, oa, attrnames, 0)

paul@64

1182

                    accessor_location = (location, oa, None, 0)

paul@64

1183

                    self.access_index[access_location] = [accessor_location]

                    self.init_access_details(access_location)

paul@64

1186

                    self.init_definition_details(accessor_location)

                    class_types, instance_types, module_types = ref.get_types()

                    self.identify_reference_attributes(access_location, attrname, class_types, instance_types, module_types, True)

paul@64

1191

                    self.record_reference_types(accessor_location, class_types, instance_types, module_types, True, True)

                original_location = (location, original_name, original_attrnames, 0)

                if original_location != access_location:

paul@64

1196

                    self.const_accesses[original_location] = access_location

paul@67

1197

                    self.const_accesses_rev[access_location] = original_location

        # Aliased name definitions. All aliases with usage will have been

paul@64

1200

        # defined, but they may be refined according to referenced accesses.

        for accessor_location in self.alias_index.keys():

paul@64

1203

            self.record_types_for_alias(accessor_location)

        # Update accesses employing aliases.

        for access_location in alias_accesses:

paul@64

1208

            self.record_types_for_access(access_location, self.access_index[access_location])

    def constrain_types(self, path, class_types, instance_types, module_types):

"""

paul@44

1213

        Using the given 'path' to an object, constrain the given 'class_types',

paul@44

1214

        'instance_types' and 'module_types'.

        Return the class, instance, module types plus whether the types are

paul@44

1217

        constrained to a specific kind of type.

paul@44

1218

"""

        ref = self.importer.identify(path)

paul@44

1221

        if ref:

            # Constrain usage suggestions using the identified object.

            if ref.has_kind("<class>"):

paul@44

1226

                return (

paul@44

1227

                    set(class_types).intersection([ref.get_origin()]), [], [], True

            elif ref.has_kind("<module>"):

paul@44

1230

                return (

paul@44

1231

                    [], [], set(module_types).intersection([ref.get_origin()]), True

        return class_types, instance_types, module_types, False

    def get_target_types(self, location, usage):

"""

paul@44

1239

        Return the class, instance and module types constrained for the name at

paul@44

1240

        the given 'location' exhibiting the given 'usage'. Whether the types

paul@44

1241

        have been constrained using contextual information is also indicated,

paul@44

1242

        plus whether the types have been constrained to a specific kind of type.

paul@44

1243

"""

        unit_path, name, attrnames, version = location

        # Detect any initialised name for the location.

        if name:

paul@44

1250

            ref = self.get_initialised_name(location)

paul@44

1251

            if ref:

paul@44

1252

                (class_types, only_instance_types, module_types,

paul@57

1253

                    _function_types, _var_types) = separate_types([ref])

paul@44

1254

                return class_types, only_instance_types, module_types, True, False

        # Retrieve the recorded types for the usage.

        class_types = self.get_class_types_for_usage(usage)

paul@44

1259

        only_instance_types = set(self.get_instance_types_for_usage(usage)).difference(class_types)

paul@44

1260

        module_types = self.get_module_types_for_usage(usage)

        # Merge usage deductions with observations to obtain reference types

paul@44

1263

        # for names involved with attribute accesses.

        if not name:

paul@44

1266

            return class_types, only_instance_types, module_types, False, False

        # Obtain references to known objects.

        path = self.get_name_path(unit_path, name)

        class_types, only_instance_types, module_types, constrained_specific = \

paul@44

1273

            self.constrain_types(path, class_types, only_instance_types, module_types)

        if constrained_specific:

paul@44

1276

            return class_types, only_instance_types, module_types, constrained_specific, constrained_specific

        # Constrain "self" references.

        if name == "self":

paul@44

1281

            t = self.constrain_self_reference(unit_path, class_types, only_instance_types)

paul@44

1282

            if t:

paul@44

1283

                class_types, only_instance_types, module_types, constrained = t

paul@44

1284

                return class_types, only_instance_types, module_types, constrained, False

        return class_types, only_instance_types, module_types, False, False

    def constrain_self_reference(self, unit_path, class_types, only_instance_types):

"""

paul@44

1291

        Where the name "self" appears in a method, attempt to constrain the

paul@44

1292

        classes involved.

        Return the class, instance, module types plus whether the types are

paul@44

1295

        constrained.

paul@44

1296

"""

        class_name = self.in_method(unit_path)

        if not class_name:

paul@44

1301

            return None

        classes = set([class_name])

paul@44

1304

        classes.update(self.get_descendants_for_class(class_name))

        # Note that only instances will be expected for these references but

paul@44

1307

        # either classes or instances may provide the attributes.

        return (

paul@44

1310

            set(class_types).intersection(classes),

paul@44

1311

            set(only_instance_types).intersection(classes),

paul@44

1312

            [], True

    def in_method(self, path):

        "Return whether 'path' refers to a method."

        class_name, method_name = path.rsplit(".", 1)

paul@44

1320

        return self.importer.classes.has_key(class_name) and class_name

    def init_reference_details(self, location):

        "Initialise reference-related details for 'location'."

        self.init_definition_details(location)

paul@44

1327

        self.init_access_details(location)

    def init_definition_details(self, location):

        "Initialise name definition details for 'location'."

        self.accessor_class_types[location] = set()

paul@44

1334

        self.accessor_instance_types[location] = set()

paul@44

1335

        self.accessor_module_types[location] = set()

paul@44

1336

        self.provider_class_types[location] = set()

paul@44

1337

        self.provider_instance_types[location] = set()

paul@44

1338

        self.provider_module_types[location] = set()

    def init_access_details(self, location):

        "Initialise access details at 'location'."

        self.referenced_attrs[location] = {}

    def record_types_for_access(self, access_location, accessor_locations, alias_accesses=None):

"""

paul@44

1349

        Define types for the 'access_location' associated with the given

paul@44

1350

        'accessor_locations'.

paul@44

1351

"""

        path, name, attrnames, version = access_location

paul@44

1354

        if not attrnames:

paul@44

1355

            return

        attrname = get_attrnames(attrnames)[0]

        # Collect all suggested types for the accessors. Accesses may

paul@44

1360

        # require accessors from of a subset of the complete set of types.

        class_types = set()

paul@44

1363

        module_types = set()

paul@44

1364

        instance_types = set()

        constrained = True

        for location in accessor_locations:

            # Remember accesses employing aliases.

            if alias_accesses is not None and self.alias_index.has_key(location):

paul@44

1373

                alias_accesses.add(access_location)

            # Use the type information deduced for names from above.

            if self.accessor_class_types.has_key(location):

paul@44

1378

                class_types.update(self.accessor_class_types[location])

paul@44

1379

                module_types.update(self.accessor_module_types[location])

paul@44

1380

                instance_types.update(self.accessor_instance_types[location])

            # Where accesses are associated with assignments but where no

paul@44

1383

            # attribute usage observations have caused such an association,

paul@44

1384

            # the attribute name is considered by itself.

            else:

paul@44

1387

                self.init_definition_details(location)

paul@44

1388

                self.record_types_for_usage(location, [attrname])

            constrained = location in self.accessor_constrained and constrained

        self.init_access_details(access_location)

paul@44

1393

        self.identify_reference_attributes(access_location, attrname, class_types, instance_types, module_types, constrained)

    def record_types_for_usage(self, accessor_location, usage):

"""

paul@44

1398

        Record types for the given 'accessor_location' according to the given

paul@44

1399

        'usage' observations which may be None to indicate an absence of usage.

paul@44

1400

"""

        (class_types,

paul@44

1403

         instance_types,

paul@44

1404

         module_types,

paul@44

1405

         constrained,

paul@44

1406

         constrained_specific) = self.get_target_types(accessor_location, usage)

        self.record_reference_types(accessor_location, class_types, instance_types, module_types, constrained, constrained_specific)

    def record_types_for_attribute(self, access_location, attrname):

"""

paul@44

1413

        Record types for the 'access_location' employing only the given

paul@44

1414

        'attrname' for type deduction.

paul@44

1415

"""

        usage = [attrname]

        class_types = self.get_class_types_for_usage(usage)

paul@44

1420

        only_instance_types = set(self.get_instance_types_for_usage(usage)).difference(class_types)

paul@44

1421

        module_types = self.get_module_types_for_usage(usage)

        self.init_reference_details(access_location)

        self.identify_reference_attributes(access_location, attrname, class_types, only_instance_types, module_types, False)

paul@44

1426

        self.record_reference_types(access_location, class_types, only_instance_types, module_types, False)

    def record_types_for_alias(self, accessor_location):

"""

paul@44

1431

        Define types for the 'accessor_location' not having associated usage.

paul@44

1432

"""

        have_access = self.provider_class_types.has_key(accessor_location)

        # With an access, attempt to narrow the existing selection of provider

paul@44

1437

        # types.

        if have_access:

paul@44

1440

            provider_class_types = self.provider_class_types[accessor_location]

paul@44

1441

            provider_instance_types = self.provider_instance_types[accessor_location]

paul@44

1442

            provider_module_types = self.provider_module_types[accessor_location]

            # Find details for any corresponding access.

            all_class_types = set()

paul@44

1447

            all_instance_types = set()

paul@44

1448

            all_module_types = set()

            for access_location in self.alias_index[accessor_location]:

paul@44

1451

                location, name, attrnames, access_number = access_location

                # Alias references an attribute access.

                if attrnames:

                    # Obtain attribute references for the access.

                    attrs = [attr for _attrtype, object_type, attr in self.referenced_attrs[access_location]]

                    # Separate the different attribute types.

                    (class_types, instance_types, module_types,

paul@57

1464

                        function_types, var_types) = separate_types(attrs)

                    # Where non-accessor types are found, do not attempt to refine

paul@44

1467

                    # the defined accessor types.

                    if function_types or var_types:

paul@44

1470

                        return

                    class_types = set(provider_class_types).intersection(class_types)

paul@44

1473

                    instance_types = set(provider_instance_types).intersection(instance_types)

paul@44

1474

                    module_types = set(provider_module_types).intersection(module_types)

                # Alias references a name, not an access.

                else:

paul@44

1479

                    # Attempt to refine the types using initialised names.

                    attr = self.get_initialised_name(access_location)

paul@44

1482

                    if attr:

paul@44

1483

                        (class_types, instance_types, module_types,

paul@57

1484

                            _function_types, _var_types) = separate_types([attr])

                    # Where no further information is found, do not attempt to

paul@44

1487

                    # refine the defined accessor types.

                    else:

paul@44

1490

                        return

                all_class_types.update(class_types)

paul@44

1493

                all_instance_types.update(instance_types)

paul@44

1494

                all_module_types.update(module_types)

            # Record refined type details for the alias as an accessor.

            self.init_definition_details(accessor_location)

paul@44

1499

            self.record_reference_types(accessor_location, all_class_types, all_instance_types, all_module_types, False)

        # Without an access, attempt to identify references for the alias.

        else:

paul@44

1504

            refs = set()

            for access_location in self.alias_index[accessor_location]:

                # Obtain any redefined constant access location.

                if self.const_accesses.has_key(access_location):

paul@64

1511

                    access_location = self.const_accesses[access_location]

                location, name, attrnames, access_number = access_location

                # Alias references an attribute access.

                if attrnames:

paul@44

1518

                    attrs = [attr for attrtype, object_type, attr in self.referenced_attrs[access_location]]

paul@44

1519

                    refs.update(attrs)

                # Alias references a name, not an access.

                else:

paul@44

1524

                    attr = self.get_initialised_name(access_location)

paul@44

1525

                    attrs = attr and [attr] or []

paul@44

1526

                    if not attrs and self.provider_class_types.has_key(access_location):

paul@44

1527

                        class_types = self.provider_class_types[access_location]

paul@44

1528

                        instance_types = self.provider_instance_types[access_location]

paul@44

1529

                        module_types = self.provider_module_types[access_location]

paul@57

1530

                        attrs = combine_types(class_types, instance_types, module_types)

paul@44

1531

                    if attrs:

paul@44

1532

                        refs.update(attrs)

            # Record reference details for the alias separately from accessors.

            self.referenced_objects[accessor_location] = refs

    def get_initialised_name(self, access_location):

"""

paul@44

1541

        Return references for any initialised names at 'access_location', or

paul@44

1542

        None if no such references exist.

paul@44

1543

"""

        location, name, attrnames, version = access_location

paul@44

1546

        path = self.get_name_path(location, name)

        # Use initialiser information, if available.

        refs = self.importer.all_initialised_names.get(path)

paul@44

1551

        if refs and refs.has_key(version):

paul@44

1552

            return refs[version]

paul@44

1553

        else:

paul@44

1554

            return None

    def get_name_path(self, path, name):

        "Return a suitable qualified name from the given 'path' and 'name'."

        if "." in name:

paul@44

1561

            return name

paul@44

1562

        else:

paul@44

1563

            return "%s.%s" % (path, name)

    def record_reference_types(self, location, class_types, instance_types,

paul@44

1566

        module_types, constrained, constrained_specific=False):

"""

paul@44

1569

        Associate attribute provider types with the given 'location', consisting

paul@44

1570

        of the given 'class_types', 'instance_types' and 'module_types'.

        If 'constrained' is indicated, the constrained nature of the accessor is

paul@44

1573

        recorded for the location.

        If 'constrained_specific' is indicated using a true value, instance types

paul@44

1576

        will not be added to class types to permit access via instances at the

paul@44

1577

        given location. This is only useful where a specific accessor is known

paul@44

1578

        to be a class.

        Note that the specified types only indicate the provider types for

paul@44

1581

        attributes, whereas the recorded accessor types indicate the possible

paul@44

1582

        types of the actual objects used to access attributes.

paul@44

1583

"""

        # Update the type details for the location.

        self.provider_class_types[location].update(class_types)

paul@44

1588

        self.provider_instance_types[location].update(instance_types)

paul@44

1589

        self.provider_module_types[location].update(module_types)

        # Class types support classes and instances as accessors.

paul@44

1592

        # Instance-only and module types support only their own kinds as

paul@44

1593

        # accessors.

        # However, the nature of accessors can be further determined.

paul@44

1596

        # Any self variable may only refer to an instance.

        path, name, version, attrnames = location

paul@44

1599

        if name != "self" or not self.in_method(path):

paul@44

1600

            self.accessor_class_types[location].update(class_types)

        if not constrained_specific:

paul@44

1603

            self.accessor_instance_types[location].update(class_types)

        self.accessor_instance_types[location].update(instance_types)

        if name != "self" or not self.in_method(path):

paul@44

1608

            self.accessor_module_types[location].update(module_types)

        if constrained:

paul@67

1611

            self.accessor_constrained.add(location)

    def identify_reference_attributes(self, location, attrname, class_types, instance_types, module_types, constrained):

"""

paul@44

1616

        Identify reference attributes, associating them with the given

paul@44

1617

        'location', identifying the given 'attrname', employing the given

paul@44

1618

        'class_types', 'instance_types' and 'module_types'.

        If 'constrained' is indicated, the constrained nature of the access is

paul@44

1621

        recorded for the location.

paul@44

1622

"""

        # Record the referenced objects.

        self.referenced_attrs[location] = \

paul@44

1627

            self._identify_reference_attribute(attrname, class_types, instance_types, module_types)

        if constrained:

paul@44

1630

            self.access_constrained.add(location)

    def _identify_reference_attribute(self, attrname, class_types, instance_types, module_types):

"""

paul@44

1635

        Identify the reference attribute with the given 'attrname', employing

paul@44

1636

        the given 'class_types', 'instance_types' and 'module_types'.

paul@44

1637

"""

        attrs = set()

        # The class types expose class attributes either directly or via

paul@44

1642

        # instances.

        for object_type in class_types:

paul@44

1645

            ref = self.importer.get_class_attribute(object_type, attrname)

paul@44

1646

            if ref:

paul@44

1647

                attrs.add(("<class>", object_type, ref))

            # Add any distinct instance attributes that would be provided

paul@44

1650

            # by instances also providing indirect class attribute access.

            for ref in self.importer.get_instance_attributes(object_type, attrname):

paul@44

1653

                attrs.add(("<instance>", object_type, ref))

        # The instance-only types expose instance attributes, but although

paul@44

1656

        # classes are excluded as potential accessors (since they do not provide

paul@44

1657

        # the instance attributes), the class types may still provide some

paul@44

1658

        # attributes.

        for object_type in instance_types:

paul@44

1661

            instance_attrs = self.importer.get_instance_attributes(object_type, attrname)

            if instance_attrs:

paul@44

1664

                for ref in instance_attrs:

paul@44

1665

                    attrs.add(("<instance>", object_type, ref))

paul@44

1666

            else:

paul@44

1667

                ref = self.importer.get_class_attribute(object_type, attrname)

paul@44

1668

                if ref:

paul@44

1669

                    attrs.add(("<class>", object_type, ref))

        # Module types expose module attributes for module accessors.

        for object_type in module_types:

paul@44

1674

            ref = self.importer.get_module_attribute(object_type, attrname)

paul@44

1675

            if ref:

paul@44

1676

                attrs.add(("<module>", object_type, ref))

        return attrs

    constrained_specific_tests = (

paul@70

1681

        "constrained-specific-instance",

paul@70

1682

        "constrained-specific-type",

paul@70

1683

        "constrained-specific-object",

    constrained_common_tests = (

paul@70

1687

        "constrained-common-instance",

paul@70

1688

        "constrained-common-type",

paul@70

1689

        "constrained-common-object",

    guarded_specific_tests = (

paul@67

1693

        "guarded-specific-instance",

paul@67

1694

        "guarded-specific-type",

paul@67

1695

        "guarded-specific-object",

    guarded_common_tests = (

paul@67

1699

        "guarded-common-instance",

paul@67

1700

        "guarded-common-type",

paul@67

1701

        "guarded-common-object",

    specific_tests = (

paul@67

1705

        "specific-instance",

paul@67

1706

        "specific-type",

paul@67

1707

        "specific-object",

    common_tests = (

paul@67

1711

        "common-instance",

paul@67

1712

        "common-type",

paul@67

1713

        "common-object",

    class_tests = (

paul@67

1717

        "guarded-specific-type",

paul@67

1718

        "guarded-common-type",

paul@67

1719

        "specific-type",

paul@67

1720

        "common-type",

    class_or_instance_tests = (

paul@67

1724

        "guarded-specific-object",

paul@67

1725

        "guarded-common-object",

paul@67

1726

        "specific-object",

paul@67

1727

        "common-object",

    def get_access_plan(self, location):

        "Return details of the access at the given 'location'."

        const_access = self.const_accesses_rev.has_key(location)

        path, name, attrname_str, version = location

paul@65

1737

        attrnames = attrname_str.split(".")

paul@65

1738

        attrname = attrnames[0]

        # Obtain reference and accessor information, retaining also distinct

paul@67

1741

        # provider kind details.

        attrs = []

paul@65

1744

        objtypes = []

paul@67

1745

        provider_kinds = set()

        for attrtype, objtype, attr in self.referenced_attrs[location]:

paul@65

1748

            attrs.append(attr)

paul@65

1749

            objtypes.append(objtype)

paul@67

1750

            provider_kinds.add(attrtype)

        # Obtain accessor type and kind information.

        accessor_types = self.reference_all_accessor_types[location]

paul@67

1755

        accessor_general_types = self.reference_all_accessor_general_types[location]

paul@67

1756

        accessor_kinds = get_kinds(accessor_general_types)

        # Determine any guard or test requirements.

        constrained = location in self.access_constrained

paul@70

1761

        test = self.reference_test_types[location]

        # Determine the accessor and provider properties.

        class_accessor = "<class>" in accessor_kinds

paul@67

1766

        module_accessor = "<module>" in accessor_kinds

paul@67

1767

        instance_accessor = "<instance>" in accessor_kinds

paul@67

1768

        provided_by_class = "<class>" in provider_kinds

paul@67

1769

        provided_by_instance = "<instance>" in provider_kinds

        # Identify the last static attribute for context acquisition.

        base = None

paul@67

1774

        dynamic_base = None

        # Constant accesses have static accessors.

        if const_access:

paul@65

1779

            base = len(objtypes) == 1 and first(objtypes)

        # Constant accessors are static.

        else:

paul@65

1784

            ref = self.importer.identify("%s.%s" % (path, name))

paul@67

1785

            if ref:

paul@65

1786

                base = ref.get_origin()

            # Usage of previously-generated guard and test details.

            elif test in self.constrained_specific_tests:

paul@67

1791

                ref = first(accessor_types)

            elif test in self.constrained_common_tests:

paul@67

1794

                ref = first(accessor_general_types)

            elif test in self.guarded_specific_tests:

paul@67

1797

                ref = first(accessor_types)

            elif test in self.guarded_common_tests:

paul@67

1800

                ref = first(accessor_general_types)

            # For attribute-based tests, tentatively identify a dynamic base.

paul@70

1803

            # Such tests allow single or multiple kinds of a type.

            elif test in self.common_tests or test in self.specific_tests:

paul@70

1806

                dynamic_base = self.reference_test_accessor_types[location]

            # Static accessors.

            if not base and test in self.class_tests:

paul@70

1811

                base = ref and ref.get_origin() or dynamic_base

            # Accessors that are not static but whose nature is determined.

            elif not base and ref:

paul@67

1816

                dynamic_base = ref.get_origin()

        traversed = []

        # Traverse remaining attributes.

        while len(attrs) == 1:

paul@65

1823

            attr = first(attrs)

            traversed.append(attrname)

paul@65

1826

            del attrnames[0]

            if not attrnames:

paul@65

1829

                break

            # Update the last static attribute.

            if attr.static():

paul@65

1834

                base = attr.get_origin()

paul@65

1835

                traversed = []

            # Get the next attribute.

            attrname = attrnames[0]

paul@65

1840

            attrs = self.importer.get_attributes(attr, attrname)

        # Where many attributes are suggested, no single attribute identity can

paul@67

1843

        # be loaded.

        else:

paul@65

1846

            attr = None

        # Determine the method of access.

        # Identified attribute that must be accessed via its parent.

        if attr and attr.get_name() and (not attr.static() or location in self.reference_assignments):

paul@71

1853

            method = "direct"; origin = attr.get_name()

        # Static, identified attribute.

        elif attr and attr.static():

paul@67

1858

            method = "static"; origin = attr.final()

        # Attribute accessed at a known position via its parent.

        elif base or dynamic_base:

paul@67

1863

            method = "relative"; origin = None

        # The fallback case is always run-time testing and access.

        else:

paul@67

1868

            l = []

paul@67

1869

            if class_accessor or module_accessor or provided_by_instance:

paul@67

1870

                l.append("checkobject")

paul@67

1871

            if instance_accessor and provided_by_class:

paul@67

1872

                l.append("checkclass")

paul@67

1873

            method = "+".join(l)

paul@67

1874

            origin = None

        return base or name, traversed, attrnames, method, test, origin

# vim: tabstop=4 expandtab shiftwidth=4

Lichen

Annotated deducer.py