Lichen (annotate deducer.py in 1b764ef8a184)

#!/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@79

23

                   get_name_path, 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@77

124

        self.reference_test_accessor_type = {}

        # 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_type.get(location):

paul@44

369

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

paul@44

370

                            sorted_output(all_accessed_attrs), \

paul@77

371

                            self.reference_test_accessor_type[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@77

396

                name, test, test_type, base, traversed, attrnames, context, \

paul@77

397

                    method, attr = self.access_plans[location]

                print >>f_attrs, encode_access_location(location), \

paul@77

400

                                 name, test, test_type or "{}", \

paul@75

401

                                 base or "{}", \

paul@67

402

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

paul@67

403

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

paul@77

404

                                 context, method, attr or "{}"

        finally:

paul@67

407

            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

414

        # defined. See: init_definition_details

        locations = self.accessor_class_types.keys()

        for location in locations:

paul@67

419

            constrained = location in self.accessor_constrained

            # Provider information.

            class_types = self.provider_class_types[location]

paul@44

424

            instance_types = self.provider_instance_types[location]

paul@44

425

            module_types = self.provider_module_types[location]

            # Collect specific and general type information.

            self.provider_all_types[location] = \

paul@57

430

                combine_types(class_types, instance_types, module_types)

            # Accessor information.

            class_types = self.accessor_class_types[location]

paul@44

435

            self.accessor_general_class_types[location] = \

paul@69

436

                general_class_types = self.get_most_general_class_types(class_types)

            instance_types = self.accessor_instance_types[location]

paul@44

439

            self.accessor_general_instance_types[location] = \

paul@69

440

                general_instance_types = self.get_most_general_class_types(instance_types)

            module_types = self.accessor_module_types[location]

paul@44

443

            self.accessor_general_module_types[location] = \

paul@44

444

                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

449

                combine_types(class_types, instance_types, module_types)

            self.accessor_all_general_types[location] = all_general_types = \

paul@57

452

                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

461

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

paul@57

462

                elif is_single_class_type(all_types):

paul@44

463

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

                # Record common type guard details.

                elif len(all_general_types) == 1:

paul@67

468

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

paul@57

469

                elif is_single_class_type(all_general_types):

paul@44

470

                    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

479

        # accessors.

        locations = self.referenced_attrs.keys()

        for location in locations:

paul@44

484

            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

491

            all_accessor_types = set()

paul@44

492

            all_accessor_general_types = set()

            for accessor_location in accessor_locations:

                # Obtain the provider types for guard-related attribute access

paul@44

497

                # 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

504

                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

509

            single_accessor_class_type = is_single_class_type(all_accessor_types)

paul@70

510

            single_accessor_general_type = len(all_accessor_general_types) == 1

paul@70

511

            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

516

                single_accessor_type or single_accessor_class_type or

paul@70

517

                single_accessor_general_type or single_accessor_general_class_type

            if guarded:

paul@44

521

                (guard_class_types, guard_instance_types, guard_module_types,

paul@57

522

                    _function_types, _var_types) = separate_types(all_provider_types)

            self.reference_all_accessor_types[location] = all_accessor_types

paul@67

525

            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

532

                raise DeduceError, location

            # Record attribute information for each name used on the

paul@71

535

            # accessor.

            attrname = get_attrname_from_location(location)

            all_accessed_attrs = set()

paul@71

540

            all_providers = set()

            # Obtain provider and attribute details for this kind of

paul@71

543

            # object.

            for attrtype, object_type, attr in referenced_attrs:

paul@71

546

                all_accessed_attrs.add(attr)

paul@71

547

                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

552

            # accessor types upheld by a guard.

            if guarded:

paul@71

555

                guard_attrs = set()

paul@71

556

                for _attrtype, object_type, attr in \

paul@71

557

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

paul@71

558

                    guard_attrs.add(attr)

paul@71

559

            else:

paul@71

560

                guard_attrs = None

            self.reference_all_attrs[location] = all_accessed_attrs

            # Constrained accesses guarantee the nature of the accessor.

paul@71

565

            # However, there may still be many types involved.

            if constrained:

paul@71

568

                if single_accessor_type:

paul@71

569

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

paul@71

570

                elif single_accessor_class_type:

paul@71

571

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

paul@71

572

                elif single_accessor_general_type:

paul@71

573

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

paul@71

574

                elif single_accessor_general_class_type:

paul@71

575

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

paul@44

576

                else:

paul@71

577

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

            # Suitably guarded accesses, where the nature of the

paul@71

580

            # accessor can be guaranteed, do not require the attribute

paul@71

581

            # involved to be validated. Otherwise, for unguarded

paul@71

582

            # accesses, access-level tests are required.

            elif guarded and all_accessed_attrs.issubset(guard_attrs):

paul@71

585

                if single_accessor_type:

paul@71

586

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

paul@71

587

                elif single_accessor_class_type:

paul@71

588

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

paul@71

589

                elif single_accessor_general_type:

paul@71

590

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

paul@71

591

                elif single_accessor_general_class_type:

paul@71

592

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

            # Record the need to test the type of anonymous and

paul@71

595

            # unconstrained accessors.

            elif len(all_providers) == 1:

paul@71

598

                provider = first(all_providers)

paul@71

599

                if provider != '__builtins__.object':

paul@71

600

                    all_accessor_kinds = set(get_kinds(all_accessor_types))

paul@71

601

                    if len(all_accessor_kinds) == 1:

paul@71

602

                        test_type = test_for_kinds("specific", all_accessor_kinds)

paul@70

603

                    else:

paul@71

604

                        test_type = "specific-object"

paul@71

605

                    self.reference_test_types[location] = test_type

paul@77

606

                    self.reference_test_accessor_type[location] = provider

            elif len(all_general_providers) == 1:

paul@71

609

                provider = first(all_general_providers)

paul@71

610

                if provider != '__builtins__.object':

paul@71

611

                    all_accessor_kinds = set(get_kinds(all_accessor_general_types))

paul@71

612

                    if len(all_accessor_kinds) == 1:

paul@71

613

                        test_type = test_for_kinds("common", all_accessor_kinds)

paul@71

614

                    else:

paul@71

615

                        test_type = "common-object"

paul@71

616

                    self.reference_test_types[location] = test_type

paul@77

617

                    self.reference_test_accessor_type[location] = provider

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

            else:

paul@71

622

                self.reference_test_types[location] = "validate"

    def initialise_access_plans(self):

        "Define attribute access plans."

        for location in self.referenced_attrs.keys():

paul@76

629

            original_location = self.const_accesses_rev.get(location)

paul@76

630

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

    def get_referenced_attrs(self, location):

"""

paul@44

635

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

paul@44

636

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

paul@44

637

"""

        d = {}

paul@69

640

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

paul@69

641

            init_item(d, attrtype, set)

paul@69

642

            d[attrtype].add(attr)

paul@69

643

        l = d.items()

paul@69

644

        l.sort() # class, module, instance

paul@44

645

        return l

    # Initialisation methods.

    def init_descendants(self):

        "Identify descendants of each class."

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

paul@44

654

            self.get_descendants_for_class(name)

    def get_descendants_for_class(self, name):

"""

paul@44

659

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

paul@44

660

        given 'name'.

paul@44

661

"""

        if not self.descendants.has_key(name):

paul@44

664

            descendants = set()

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

paul@44

667

                descendants.update(self.get_descendants_for_class(subclass))

paul@44

668

                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

681

            for descendant in descendants:

paul@44

682

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

        for name in all_class_attrs.keys():

paul@44

685

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

    def init_usage_index(self):

"""

paul@44

690

        Create indexes for module and function attribute usage and for anonymous

paul@44

691

        accesses.

paul@44

692

"""

        for module in self.importer.get_modules():

paul@44

695

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

paul@44

696

                self.add_usage(assignments, path)

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

paul@44

699

            for attrnames in all_attrnames:

paul@44

700

                attrname = get_attrnames(attrnames)[-1]

paul@44

701

                access_location = (location, None, attrnames, 0)

paul@44

702

                self.add_usage_term(access_location, [attrname])

    def add_usage(self, assignments, path):

"""

paul@44

707

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

paul@44

708

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

paul@44

709

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

paul@44

710

"""

        for name, versions in assignments.items():

paul@44

713

            for i, usages in enumerate(versions):

paul@44

714

                location = (path, name, None, i)

                for attrnames in usages:

paul@44

717

                    self.add_usage_term(location, attrnames)

    def add_usage_term(self, location, attrnames):

"""

paul@44

722

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

paul@44

723

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

paul@44

724

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

paul@44

725

"""

        key = make_key(attrnames)

        init_item(self.location_index, location, set)

paul@44

730

        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

737

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

paul@44

738

                self.add_accessors(all_accesses, path)

    def add_accessors(self, all_accesses, path):

"""

paul@44

743

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

paul@44

744

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

paul@44

745

        for each access.

paul@44

746

"""

        # 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

755

                access_location = (path, name, attrnames, access_number)

paul@44

756

                locations = []

                for version in versions:

paul@44

759

                    location = (path, name, None, version)

paul@44

760

                    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

769

            return self.access_index[access_location]

paul@44

770

        except KeyError:

paul@44

771

            return [access_location]

    def init_accesses(self):

"""

paul@44

776

        Initialise collections for accesses involving assignments.

paul@44

777

"""

        # 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

784

            # applicable modifiers.

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

                # For each access, determine the name versions affected by

paul@44

789

                # assignments.

                for access_number, modifier in enumerate(modifiers):

paul@44

792

                    if name:

paul@44

793

                        access_location = (path, name, attrnames, access_number)

paul@44

794

                    else:

paul@44

795

                        access_location = (path, None, attrnames, 0)

                    assignment = modifier == "A"

paul@71

798

                    if assignment:

paul@71

799

                        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

806

                        for usage in self.location_index[location]:

paul@44

807

                            key = make_key(usage)

                            if assignment:

paul@44

810

                                init_item(self.assigned_attrs, key, set)

paul@44

811

                                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

820

            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

825

                accessor_location = (path, name, None, version)

paul@44

826

                access_location = (path, original_name, attrnames, access_number)

paul@44

827

                init_item(self.alias_index, accessor_location, list)

paul@44

828

                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

833

            self.update_aliases(accessor_location, access_locations)

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

"""

paul@44

838

        Update the given 'accessor_location' defining an alias, update

paul@44

839

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

paul@44

840

        via the access index.

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

paul@44

843

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

paul@44

844

"""

        if visited is None:

paul@44

847

            visited = set()

        updated_locations = set()

        for access_location in access_locations:

paul@44

852

            (path, original_name, attrnames, access_number) = access_location

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

paul@44

855

            # version details.

            if attrnames is None:

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

paul@44

860

                # 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

867

                        continue

                    visited.add(name_accessor_location)

                    name_access_locations = self.alias_index.get(name_accessor_location)

paul@44

872

                    if name_access_locations:

paul@44

873

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

paul@44

874

                    else:

paul@44

875

                        updated_locations.add(name_accessor_location)

            # Otherwise, record the access details.

            else:

paul@44

880

                updated_locations.add(access_location)

        self.alias_index[accessor_location] = updated_locations

paul@44

883

        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

894

            if not usage:

paul@44

895

                continue

            for path, name, attrnames in all_attrnames:

paul@44

898

                class_types = self.get_class_types_for_usage(usage)

paul@44

899

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

paul@44

900

                module_types = self.get_module_types_for_usage(usage)

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

paul@44

903

                # of the mutation.

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

paul@44

906

                if t:

paul@44

907

                    class_types, only_instance_types, module_types, constrained = t

paul@44

908

                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

917

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

paul@44

918

            value = self.importer.get_object(attr)

            # If the value is None, the attribute is

paul@44

921

            # inherited and need not be set explicitly on

paul@44

922

            # the class concerned.

            if value:

paul@44

925

                self.modified_attributes[attr] = value

paul@44

926

                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

935

        class_types = set()

        for type in types:

paul@69

938

            ref = self.importer.identify(type)

paul@69

939

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

paul@69

940

                module_types.add(type)

paul@69

941

            else:

paul@69

942

                class_types.add(type)

        types = set(self.get_most_general_module_types(module_types))

paul@69

945

        types.update(self.get_most_general_class_types(class_types))

paul@69

946

        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

953

        to_remove = set()

        for class_type in class_types:

paul@44

956

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

paul@44

957

                base = base.get_origin()

paul@44

958

                descendants = self.descendants[base]

paul@44

959

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

paul@44

960

                    to_remove.update(descendants)

        class_types.difference_update(to_remove)

paul@44

963

        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

970

        # attributes.

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

paul@44

973

            return ["__builtins__.object"]

paul@44

974

        else:

paul@44

975

            return module_types

    # Type deduction for usage.

    def get_types_for_usage(self, attrnames, objects):

"""

paul@44

982

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

paul@44

983

        given 'objects' as the catalogue of type details.

paul@44

984

"""

        types = []

paul@44

987

        for name, _attrnames in objects.items():

paul@44

988

            if set(attrnames).issubset(_attrnames):

paul@44

989

                types.append(name)

paul@44

990

        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

999

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

paul@44

1000

        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

1005

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

paul@44

1006

        'attrs' type-to-attributes mapping.

paul@44

1007

"""

        for name, attrnames in attrs.items():

paul@44

1010

            for attrname in attrnames:

paul@44

1011

                init_item(attr_types, attrname, set)

paul@44

1012

                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

1023

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

paul@44

1024

        (as either class or instance attributes).

paul@44

1025

"""

        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

1038

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

paul@44

1039

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

paul@44

1040

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

paul@44

1041

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

paul@44

1042

"""

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

        if not attrnames:

paul@44

1047

            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

1058

            if set(attrnames).issubset(_attrnames):

paul@44

1059

                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

1074

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

paul@44

1075

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

paul@44

1076

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

            have_usage = False

paul@44

1079

            have_no_usage_branch = False

            for usage in usages:

paul@44

1082

                if not usage:

paul@44

1083

                    have_no_usage_branch = True

paul@44

1084

                    continue

paul@44

1085

                elif not have_usage:

paul@44

1086

                    self.init_definition_details(location)

paul@44

1087

                    have_usage = True

paul@44

1088

                self.record_types_for_usage(location, usage)

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

paul@44

1091

            # occur, record the types for those branches anyway.

            if have_usage and have_no_usage_branch:

paul@44

1094

                self.init_definition_details(location)

paul@44

1095

                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

1102

            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

1113

                all_attrnames.update(get_attrnames(attrnames))

            # Get attribute and accessor details for each attribute name.

            for attrname in all_attrnames:

paul@44

1118

                access_location = (location, None, attrname, 0)

paul@44

1119

                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

1126

            # details.

            for original_access, access in name_accesses.items():

paul@44

1129

                original_name, original_attrnames = original_access

paul@44

1130

                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

1141

                    # details, exposing the final attribute name.

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

paul@44

1144

                    oa = ".".join(oa)

                    access_location = (location, oa, attrname, 0)

paul@44

1147

                    accessor_location = (location, oa, None, 0)

paul@44

1148

                    self.access_index[access_location] = [accessor_location]

                    self.init_access_details(access_location)

paul@44

1151

                    self.init_definition_details(accessor_location)

                    # Obtain a reference for the accessor in order to properly

paul@44

1154

                    # determine its type.

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

paul@44

1157

                        objpath = ref.get_origin()

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

                    # Where the object name conflicts with the module

paul@44

1162

                    # providing it, obtain the module details.

                    if objpath in self.importer.modules:

paul@44

1165

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

paul@44

1166

                    else:

paul@44

1167

                        accessor = self.importer.get_object(objpath)

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

paul@44

1170

                    self.access_constrained.add(access_location)

                    class_types, instance_types, module_types = accessor.get_types()

paul@44

1173

                    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

1178

                    # details, employing the first remaining attribute name.

                    l = get_attrnames(attrnames)

paul@64

1181

                    attrname = l[0]

                    oa = original_accessor[:-len(l)]

paul@64

1184

                    oa = ".".join(oa)

                    access_location = (location, oa, attrnames, 0)

paul@64

1187

                    accessor_location = (location, oa, None, 0)

paul@64

1188

                    self.access_index[access_location] = [accessor_location]

                    self.init_access_details(access_location)

paul@64

1191

                    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

1196

                    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

1201

                    self.const_accesses[original_location] = access_location

paul@67

1202

                    self.const_accesses_rev[access_location] = original_location

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

paul@64

1205

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

        for accessor_location in self.alias_index.keys():

paul@64

1208

            self.record_types_for_alias(accessor_location)

        # Update accesses employing aliases.

        for access_location in alias_accesses:

paul@64

1213

            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

1218

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

paul@44

1219

        'instance_types' and 'module_types'.

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

paul@44

1222

        constrained to a specific kind of type.

paul@44

1223

"""

        ref = self.importer.identify(path)

paul@44

1226

        if ref:

            # Constrain usage suggestions using the identified object.

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

paul@44

1231

                return (

paul@44

1232

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

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

paul@44

1235

                return (

paul@44

1236

                    [], [], 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

1244

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

paul@44

1245

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

paul@44

1246

        have been constrained using contextual information is also indicated,

paul@44

1247

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

paul@44

1248

"""

        unit_path, name, attrnames, version = location

        # Detect any initialised name for the location.

        if name:

paul@44

1255

            ref = self.get_initialised_name(location)

paul@44

1256

            if ref:

paul@44

1257

                (class_types, only_instance_types, module_types,

paul@57

1258

                    _function_types, _var_types) = separate_types([ref])

paul@44

1259

                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

1264

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

paul@44

1265

        module_types = self.get_module_types_for_usage(usage)

        # Merge usage deductions with observations to obtain reference types

paul@44

1268

        # for names involved with attribute accesses.

        if not name:

paul@44

1271

            return class_types, only_instance_types, module_types, False, False

        # Obtain references to known objects.

        path = get_name_path(unit_path, name)

        class_types, only_instance_types, module_types, constrained_specific = \

paul@44

1278

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

        if constrained_specific:

paul@44

1281

            return class_types, only_instance_types, module_types, constrained_specific, constrained_specific

        # Constrain "self" references.

        if name == "self":

paul@44

1286

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

paul@44

1287

            if t:

paul@44

1288

                class_types, only_instance_types, module_types, constrained = t

paul@44

1289

                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

1296

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

paul@44

1297

        classes involved.

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

paul@44

1300

        constrained.

paul@44

1301

"""

        class_name = self.in_method(unit_path)

        if not class_name:

paul@44

1306

            return None

        classes = set([class_name])

paul@44

1309

        classes.update(self.get_descendants_for_class(class_name))

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

paul@44

1312

        # either classes or instances may provide the attributes.

        return (

paul@44

1315

            set(class_types).intersection(classes),

paul@44

1316

            set(only_instance_types).intersection(classes),

paul@44

1317

            [], True

    def in_method(self, path):

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

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

paul@44

1325

        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

1332

        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

1339

        self.accessor_instance_types[location] = set()

paul@44

1340

        self.accessor_module_types[location] = set()

paul@44

1341

        self.provider_class_types[location] = set()

paul@44

1342

        self.provider_instance_types[location] = set()

paul@44

1343

        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

1354

        Define types for the 'access_location' associated with the given

paul@44

1355

        'accessor_locations'.

paul@44

1356

"""

        path, name, attrnames, version = access_location

paul@44

1359

        if not attrnames:

paul@44

1360

            return

        attrname = get_attrnames(attrnames)[0]

        # Collect all suggested types for the accessors. Accesses may

paul@44

1365

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

        class_types = set()

paul@44

1368

        module_types = set()

paul@44

1369

        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

1378

                alias_accesses.add(access_location)

            # Use the type information deduced for names from above.

            if self.accessor_class_types.has_key(location):

paul@44

1383

                class_types.update(self.accessor_class_types[location])

paul@44

1384

                module_types.update(self.accessor_module_types[location])

paul@44

1385

                instance_types.update(self.accessor_instance_types[location])

            # Where accesses are associated with assignments but where no

paul@44

1388

            # attribute usage observations have caused such an association,

paul@44

1389

            # the attribute name is considered by itself.

            else:

paul@44

1392

                self.init_definition_details(location)

paul@44

1393

                self.record_types_for_usage(location, [attrname])

            constrained = location in self.accessor_constrained and constrained

        self.init_access_details(access_location)

paul@44

1398

        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

1403

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

paul@44

1404

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

paul@44

1405

"""

        (class_types,

paul@44

1408

         instance_types,

paul@44

1409

         module_types,

paul@44

1410

         constrained,

paul@44

1411

         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

1418

        Record types for the 'access_location' employing only the given

paul@44

1419

        'attrname' for type deduction.

paul@44

1420

"""

        usage = [attrname]

        class_types = self.get_class_types_for_usage(usage)

paul@44

1425

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

paul@44

1426

        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

1431

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

    def record_types_for_alias(self, accessor_location):

"""

paul@44

1436

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

paul@44

1437

"""

        have_access = self.provider_class_types.has_key(accessor_location)

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

paul@44

1442

        # types.

        if have_access:

paul@44

1445

            provider_class_types = self.provider_class_types[accessor_location]

paul@44

1446

            provider_instance_types = self.provider_instance_types[accessor_location]

paul@44

1447

            provider_module_types = self.provider_module_types[accessor_location]

            # Find details for any corresponding access.

            all_class_types = set()

paul@44

1452

            all_instance_types = set()

paul@44

1453

            all_module_types = set()

            for access_location in self.alias_index[accessor_location]:

paul@44

1456

                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

1469

                        function_types, var_types) = separate_types(attrs)

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

paul@44

1472

                    # the defined accessor types.

                    if function_types or var_types:

paul@44

1475

                        return

                    class_types = set(provider_class_types).intersection(class_types)

paul@44

1478

                    instance_types = set(provider_instance_types).intersection(instance_types)

paul@44

1479

                    module_types = set(provider_module_types).intersection(module_types)

                # Alias references a name, not an access.

                else:

paul@44

1484

                    # Attempt to refine the types using initialised names.

                    attr = self.get_initialised_name(access_location)

paul@44

1487

                    if attr:

paul@44

1488

                        (class_types, instance_types, module_types,

paul@57

1489

                            _function_types, _var_types) = separate_types([attr])

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

paul@44

1492

                    # refine the defined accessor types.

                    else:

paul@44

1495

                        return

                all_class_types.update(class_types)

paul@44

1498

                all_instance_types.update(instance_types)

paul@44

1499

                all_module_types.update(module_types)

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

            self.init_definition_details(accessor_location)

paul@44

1504

            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

1509

            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

1516

                    access_location = self.const_accesses[access_location]

                location, name, attrnames, access_number = access_location

                # Alias references an attribute access.

                if attrnames:

paul@44

1523

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

paul@44

1524

                    refs.update(attrs)

                # Alias references a name, not an access.

                else:

paul@44

1529

                    attr = self.get_initialised_name(access_location)

paul@44

1530

                    attrs = attr and [attr] or []

paul@44

1531

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

paul@44

1532

                        class_types = self.provider_class_types[access_location]

paul@44

1533

                        instance_types = self.provider_instance_types[access_location]

paul@44

1534

                        module_types = self.provider_module_types[access_location]

paul@57

1535

                        attrs = combine_types(class_types, instance_types, module_types)

paul@44

1536

                    if attrs:

paul@44

1537

                        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

1546

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

paul@44

1547

        None if no such references exist.

paul@44

1548

"""

        location, name, attrnames, version = access_location

paul@79

1551

        path = get_name_path(location, name)

        # Use initialiser information, if available.

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

paul@44

1556

        if refs and refs.has_key(version):

paul@44

1557

            return refs[version]

paul@44

1558

        else:

paul@44

1559

            return None

    def record_reference_types(self, location, class_types, instance_types,

paul@44

1562

        module_types, constrained, constrained_specific=False):

"""

paul@44

1565

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

paul@44

1566

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

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

paul@44

1569

        recorded for the location.

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

paul@44

1572

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

paul@44

1573

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

paul@44

1574

        to be a class.

        Note that the specified types only indicate the provider types for

paul@44

1577

        attributes, whereas the recorded accessor types indicate the possible

paul@44

1578

        types of the actual objects used to access attributes.

paul@44

1579

"""

        # Update the type details for the location.

        self.provider_class_types[location].update(class_types)

paul@44

1584

        self.provider_instance_types[location].update(instance_types)

paul@44

1585

        self.provider_module_types[location].update(module_types)

        # Class types support classes and instances as accessors.

paul@44

1588

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

paul@44

1589

        # accessors.

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

paul@44

1592

        # Any self variable may only refer to an instance.

        path, name, version, attrnames = location

paul@44

1595

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

paul@44

1596

            self.accessor_class_types[location].update(class_types)

        if not constrained_specific:

paul@44

1599

            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

1604

            self.accessor_module_types[location].update(module_types)

        if constrained:

paul@67

1607

            self.accessor_constrained.add(location)

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

"""

paul@44

1612

        Identify reference attributes, associating them with the given

paul@44

1613

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

paul@44

1614

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

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

paul@44

1617

        recorded for the location.

paul@44

1618

"""

        # Record the referenced objects.

        self.referenced_attrs[location] = \

paul@44

1623

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

        if constrained:

paul@44

1626

            self.access_constrained.add(location)

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

"""

paul@44

1631

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

paul@44

1632

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

paul@44

1633

"""

        attrs = set()

        # The class types expose class attributes either directly or via

paul@44

1638

        # instances.

        for object_type in class_types:

paul@44

1641

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

paul@44

1642

            if ref:

paul@44

1643

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

            # Add any distinct instance attributes that would be provided

paul@44

1646

            # by instances also providing indirect class attribute access.

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

paul@44

1649

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

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

paul@44

1652

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

paul@44

1653

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

paul@44

1654

        # attributes.

        for object_type in instance_types:

paul@44

1657

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

            if instance_attrs:

paul@44

1660

                for ref in instance_attrs:

paul@44

1661

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

paul@44

1662

            else:

paul@44

1663

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

paul@44

1664

                if ref:

paul@44

1665

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

        # Module types expose module attributes for module accessors.

        for object_type in module_types:

paul@44

1670

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

paul@44

1671

            if ref:

paul@44

1672

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

        return attrs

    constrained_specific_tests = (

paul@70

1677

        "constrained-specific-instance",

paul@70

1678

        "constrained-specific-type",

paul@70

1679

        "constrained-specific-object",

    constrained_common_tests = (

paul@70

1683

        "constrained-common-instance",

paul@70

1684

        "constrained-common-type",

paul@70

1685

        "constrained-common-object",

    guarded_specific_tests = (

paul@67

1689

        "guarded-specific-instance",

paul@67

1690

        "guarded-specific-type",

paul@67

1691

        "guarded-specific-object",

    guarded_common_tests = (

paul@67

1695

        "guarded-common-instance",

paul@67

1696

        "guarded-common-type",

paul@67

1697

        "guarded-common-object",

    specific_tests = (

paul@67

1701

        "specific-instance",

paul@67

1702

        "specific-type",

paul@67

1703

        "specific-object",

    common_tests = (

paul@67

1707

        "common-instance",

paul@67

1708

        "common-type",

paul@67

1709

        "common-object",

    class_tests = (

paul@67

1713

        "guarded-specific-type",

paul@67

1714

        "guarded-common-type",

paul@67

1715

        "specific-type",

paul@67

1716

        "common-type",

    class_or_instance_tests = (

paul@67

1720

        "guarded-specific-object",

paul@67

1721

        "guarded-common-object",

paul@67

1722

        "specific-object",

paul@67

1723

        "common-object",

    def get_access_plan(self, location):

"""

paul@77

1729

        Return details of the access at the given 'location'. The details are as

paul@77

1730

        follows:

         * the initial accessor (from which accesses will be performed if no

paul@77

1733

           computed static accessor is found)

paul@77

1734

         * details of any test required on the initial accessor

paul@77

1735

         * details of any type employed by the test

paul@77

1736

         * any static accessor (from which accesses will be performed in

paul@77

1737

           preference to the initial accessor)

paul@77

1738

         * attributes needing to be traversed from the base that yield

paul@77

1739

           unambiguous objects

paul@77

1740

         * remaining attributes needing to be tested and traversed

paul@77

1741

         * details of the context

paul@77

1742

         * the method of obtaining the final attribute

paul@77

1743

         * any static final attribute

paul@77

1744

"""

        const_access = self.const_accesses_rev.has_key(location)

        path, name, attrnames, version = location

paul@75

1749

        remaining = attrnames.split(".")

paul@75

1750

        attrname = remaining[0]

        # Obtain reference and accessor information, retaining also distinct

paul@67

1753

        # provider kind details.

        attrs = []

paul@65

1756

        objtypes = []

paul@67

1757

        provider_kinds = set()

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

paul@65

1760

            attrs.append(attr)

paul@65

1761

            objtypes.append(objtype)

paul@67

1762

            provider_kinds.add(attrtype)

        # Obtain accessor type and kind information.

        accessor_types = self.reference_all_accessor_types[location]

paul@67

1767

        accessor_general_types = self.reference_all_accessor_general_types[location]

paul@67

1768

        accessor_kinds = get_kinds(accessor_general_types)

        # Determine any guard or test requirements.

        constrained = location in self.access_constrained

paul@70

1773

        test = self.reference_test_types[location]

paul@77

1774

        test_type = self.reference_test_accessor_type.get(location)

        # Determine the accessor and provider properties.

        class_accessor = "<class>" in accessor_kinds

paul@67

1779

        module_accessor = "<module>" in accessor_kinds

paul@67

1780

        instance_accessor = "<instance>" in accessor_kinds

paul@67

1781

        provided_by_class = "<class>" in provider_kinds

paul@67

1782

        provided_by_instance = "<instance>" in provider_kinds

        # Determine how attributes may be accessed relative to the accessor.

        object_relative = class_accessor or module_accessor or provided_by_instance

paul@74

1787

        class_relative = instance_accessor and provided_by_class

        # Identify the last static attribute for context acquisition.

        base = None

paul@67

1792

        dynamic_base = None

        # Constant accesses have static accessors.

        if const_access:

paul@65

1797

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

        # Constant accessors are static.

        else:

paul@65

1802

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

paul@67

1803

            if ref:

paul@65

1804

                base = ref.get_origin()

            # Usage of previously-generated guard and test details.

            elif test in self.constrained_specific_tests:

paul@67

1809

                ref = first(accessor_types)

            elif test in self.constrained_common_tests:

paul@67

1812

                ref = first(accessor_general_types)

            elif test in self.guarded_specific_tests:

paul@67

1815

                ref = first(accessor_types)

            elif test in self.guarded_common_tests:

paul@67

1818

                ref = first(accessor_general_types)

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

paul@70

1821

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

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

paul@77

1824

                dynamic_base = test_type

            # Static accessors.

            if not base and test in self.class_tests:

paul@70

1829

                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

1834

                dynamic_base = ref.get_origin()

        traversed = []

        # Traverse remaining attributes.

        while len(attrs) == 1:

paul@65

1841

            attr = first(attrs)

            traversed.append(attrname)

paul@75

1844

            del remaining[0]

            if not remaining:

paul@65

1847

                break

            # Update the last static attribute.

            if attr.static():

paul@65

1852

                base = attr.get_origin()

paul@65

1853

                traversed = []

            # Get the next attribute.

            attrname = remaining[0]

paul@65

1858

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

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

paul@67

1861

        # be loaded.

        else:

paul@65

1864

            attr = None

        # Determine the method of access.

        # Identified attribute that must be accessed via its parent.

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

paul@71

1871

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

        # Static, identified attribute.

        elif attr and attr.static():

paul@67

1876

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

        # Attribute accessed at a known position via its parent.

        elif base or dynamic_base:

paul@74

1881

            method = "relative" + (object_relative and "-object" or "") + \

paul@74

1882

                                  (class_relative and "-class" or "")

paul@74

1883

            origin = None

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

        else:

paul@74

1888

            method = "check" + (object_relative and "-object" or "") + \

paul@74

1889

                               (class_relative and "-class" or "")

paul@67

1890

            origin = None

        # Determine the nature of the context.

        context = base and "base" or len(traversed or remaining) > 1 and "traversal" or "accessor"

        return name, test, test_type, base, traversed, remaining, context, method, origin

# vim: tabstop=4 expandtab shiftwidth=4

Lichen

Annotated deducer.py