Lichen (annotate deducer.py in c7ddfc4525da)

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

23

                   get_invoked_attributes, get_name_path, init_item, \

paul@90

24

                   sorted_output, 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@87

532

                raise DeduceError, repr(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@88

702

                self.add_usage_term(access_location, ((attrname, False),))

    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 usage in usages:

paul@88

717

                    self.add_usage_term(location, usage)

    def add_usage_term(self, location, usage):

"""

paul@88

722

        For 'location' and using 'usage' 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

"""

        init_item(self.location_index, location, set)

paul@88

728

        self.location_index[location].add(usage)

    def init_accessors(self):

        "Create indexes for module and function accessor information."

        for module in self.importer.get_modules():

paul@44

735

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

paul@44

736

                self.add_accessors(all_accesses, path)

    def add_accessors(self, all_accesses, path):

"""

paul@44

741

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

paul@44

742

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

paul@44

743

        for each access.

paul@44

744

"""

        # 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

753

                access_location = (path, name, attrnames, access_number)

paul@44

754

                locations = []

                for version in versions:

paul@44

757

                    location = (path, name, None, version)

paul@44

758

                    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

767

            return self.access_index[access_location]

paul@44

768

        except KeyError:

paul@44

769

            return [access_location]

    def init_accesses(self):

"""

paul@44

774

        Initialise collections for accesses involving assignments.

paul@44

775

"""

        # 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

782

            # applicable modifiers.

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

                # For each access, determine the name versions affected by

paul@44

787

                # assignments.

                for access_number, assignment in enumerate(modifiers):

paul@44

790

                    if name:

paul@44

791

                        access_location = (path, name, attrnames, access_number)

paul@44

792

                    else:

paul@44

793

                        access_location = (path, None, attrnames, 0)

                    if assignment:

paul@71

796

                        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

803

                        for usage in self.location_index[location]:

paul@44

804

                            if assignment:

paul@88

805

                                init_item(self.assigned_attrs, usage, set)

paul@88

806

                                self.assigned_attrs[usage].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

    # 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

979

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

paul@44

980

        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

985

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

paul@44

986

        'attrs' type-to-attributes mapping.

paul@44

987

"""

        for name, attrnames in attrs.items():

paul@44

990

            for attrname in attrnames:

paul@44

991

                init_item(attr_types, attrname, set)

paul@44

992

                attr_types[attrname].add(name)

    def get_class_types_for_usage(self, usage):

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

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

    def get_instance_types_for_usage(self, usage):

"""

paul@88

1003

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

paul@44

1004

        (as either class or instance attributes).

paul@44

1005

"""

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

    def get_module_types_for_usage(self, usage):

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

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

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

"""

paul@88

1018

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

paul@44

1019

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

paul@44

1020

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

paul@44

1021

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

paul@44

1022

"""

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

        if not usage:

paul@44

1027

            return attrs.keys()

        attrnames = []

paul@88

1030

        for attrname, invocation in usage:

paul@88

1031

            attrnames.append(attrname)

        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

1042

            if set(attrnames).issubset(_attrnames):

paul@44

1043

                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

1058

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

paul@44

1059

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

paul@44

1060

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

            have_usage = False

paul@44

1063

            have_no_usage_branch = False

            for usage in usages:

paul@44

1066

                if not usage:

paul@44

1067

                    have_no_usage_branch = True

paul@44

1068

                    continue

paul@44

1069

                elif not have_usage:

paul@44

1070

                    self.init_definition_details(location)

paul@44

1071

                    have_usage = True

paul@44

1072

                self.record_types_for_usage(location, usage)

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

paul@44

1075

            # occur, record the types for those branches anyway.

            if have_usage and have_no_usage_branch:

paul@44

1078

                self.init_definition_details(location)

paul@44

1079

                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

1086

            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

1097

                all_attrnames.update(get_attrnames(attrnames))

            # Get attribute and accessor details for each attribute name.

            for attrname in all_attrnames:

paul@44

1102

                access_location = (location, None, attrname, 0)

paul@44

1103

                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

1110

            # details.

            for original_access, access in name_accesses.items():

paul@44

1113

                original_name, original_attrnames = original_access

paul@44

1114

                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

1125

                    # details, exposing the final attribute name.

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

paul@44

1128

                    oa = ".".join(oa)

                    access_location = (location, oa, attrname, 0)

paul@44

1131

                    accessor_location = (location, oa, None, 0)

paul@44

1132

                    self.access_index[access_location] = [accessor_location]

                    self.init_access_details(access_location)

paul@44

1135

                    self.init_definition_details(accessor_location)

                    # Obtain a reference for the accessor in order to properly

paul@44

1138

                    # determine its type.

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

paul@44

1141

                        objpath = ref.get_origin()

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

                    # Where the object name conflicts with the module

paul@44

1146

                    # providing it, obtain the module details.

                    if objpath in self.importer.modules:

paul@44

1149

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

paul@44

1150

                    else:

paul@44

1151

                        accessor = self.importer.get_object(objpath)

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

paul@44

1154

                    self.access_constrained.add(access_location)

                    class_types, instance_types, module_types = accessor.get_types()

paul@44

1157

                    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

1162

                    # details, employing the first remaining attribute name.

                    l = get_attrnames(attrnames)

paul@64

1165

                    attrname = l[0]

                    oa = original_accessor[:-len(l)]

paul@64

1168

                    oa = ".".join(oa)

                    access_location = (location, oa, attrnames, 0)

paul@64

1171

                    accessor_location = (location, oa, None, 0)

paul@64

1172

                    self.access_index[access_location] = [accessor_location]

                    self.init_access_details(access_location)

paul@64

1175

                    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

1180

                    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

1185

                    self.const_accesses[original_location] = access_location

paul@67

1186

                    self.const_accesses_rev[access_location] = original_location

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

paul@64

1189

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

        for accessor_location in self.alias_index.keys():

paul@64

1192

            self.record_types_for_alias(accessor_location)

        # Update accesses employing aliases.

        for access_location in alias_accesses:

paul@64

1197

            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

1202

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

paul@44

1203

        'instance_types' and 'module_types'.

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

paul@44

1206

        constrained to a specific kind of type.

paul@44

1207

"""

        ref = self.importer.identify(path)

paul@44

1210

        if ref:

            # Constrain usage suggestions using the identified object.

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

paul@44

1215

                return (

paul@44

1216

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

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

paul@44

1219

                return (

paul@44

1220

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

1228

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

paul@44

1229

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

paul@44

1230

        have been constrained using contextual information is also indicated,

paul@44

1231

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

paul@44

1232

"""

        unit_path, name, attrnames, version = location

        # Detect any initialised name for the location.

        if name:

paul@44

1239

            ref = self.get_initialised_name(location)

paul@44

1240

            if ref:

paul@44

1241

                (class_types, only_instance_types, module_types,

paul@57

1242

                    _function_types, _var_types) = separate_types([ref])

paul@44

1243

                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

1248

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

paul@44

1249

        module_types = self.get_module_types_for_usage(usage)

        # Merge usage deductions with observations to obtain reference types

paul@44

1252

        # for names involved with attribute accesses.

        if not name:

paul@44

1255

            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

1262

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

        if constrained_specific:

paul@44

1265

            return class_types, only_instance_types, module_types, constrained_specific, constrained_specific

        # Constrain "self" references.

        if name == "self":

paul@44

1270

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

paul@44

1271

            if t:

paul@44

1272

                class_types, only_instance_types, module_types, constrained = t

paul@44

1273

                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

1280

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

paul@44

1281

        classes involved.

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

paul@44

1284

        constrained.

paul@44

1285

"""

        class_name = self.in_method(unit_path)

        if not class_name:

paul@44

1290

            return None

        classes = set([class_name])

paul@44

1293

        classes.update(self.get_descendants_for_class(class_name))

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

paul@44

1296

        # either classes or instances may provide the attributes.

        return (

paul@44

1299

            set(class_types).intersection(classes),

paul@44

1300

            set(only_instance_types).intersection(classes),

paul@44

1301

            [], True

    def in_method(self, path):

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

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

paul@44

1309

        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

1316

        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

1323

        self.accessor_instance_types[location] = set()

paul@44

1324

        self.accessor_module_types[location] = set()

paul@44

1325

        self.provider_class_types[location] = set()

paul@44

1326

        self.provider_instance_types[location] = set()

paul@44

1327

        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

1338

        Define types for the 'access_location' associated with the given

paul@44

1339

        'accessor_locations'.

paul@44

1340

"""

        path, name, attrnames, version = access_location

paul@44

1343

        if not attrnames:

paul@44

1344

            return

        attrname = get_attrnames(attrnames)[0]

        # Collect all suggested types for the accessors. Accesses may

paul@44

1349

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

        class_types = set()

paul@44

1352

        module_types = set()

paul@44

1353

        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

1362

                alias_accesses.add(access_location)

            # Use the type information deduced for names from above.

            if self.accessor_class_types.has_key(location):

paul@44

1367

                class_types.update(self.accessor_class_types[location])

paul@44

1368

                module_types.update(self.accessor_module_types[location])

paul@44

1369

                instance_types.update(self.accessor_instance_types[location])

            # Where accesses are associated with assignments but where no

paul@44

1372

            # attribute usage observations have caused such an association,

paul@44

1373

            # the attribute name is considered by itself.

            else:

paul@44

1376

                self.init_definition_details(location)

paul@88

1377

                self.record_types_for_usage(location, [(attrname, False)])

            constrained = location in self.accessor_constrained and constrained

        self.init_access_details(access_location)

paul@44

1382

        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

1387

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

paul@44

1388

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

paul@44

1389

"""

        (class_types,

paul@44

1392

         instance_types,

paul@44

1393

         module_types,

paul@44

1394

         constrained,

paul@44

1395

         constrained_specific) = self.get_target_types(accessor_location, usage)

        invocations = get_invoked_attributes(usage)

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

    def record_types_for_attribute(self, access_location, attrname):

"""

paul@44

1404

        Record types for the 'access_location' employing only the given

paul@44

1405

        'attrname' for type deduction.

paul@44

1406

"""

        usage = ((attrname, False),)

        class_types = self.get_class_types_for_usage(usage)

paul@44

1411

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

paul@44

1412

        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

1417

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

    def record_types_for_alias(self, accessor_location):

"""

paul@44

1422

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

paul@44

1423

"""

        have_access = self.provider_class_types.has_key(accessor_location)

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

paul@44

1428

        # types.

        if have_access:

paul@44

1431

            provider_class_types = self.provider_class_types[accessor_location]

paul@44

1432

            provider_instance_types = self.provider_instance_types[accessor_location]

paul@44

1433

            provider_module_types = self.provider_module_types[accessor_location]

            # Find details for any corresponding access.

            all_class_types = set()

paul@44

1438

            all_instance_types = set()

paul@44

1439

            all_module_types = set()

            for access_location in self.alias_index[accessor_location]:

paul@44

1442

                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

1455

                        function_types, var_types) = separate_types(attrs)

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

paul@44

1458

                    # the defined accessor types.

                    if function_types or var_types:

paul@44

1461

                        return

                    class_types = set(provider_class_types).intersection(class_types)

paul@44

1464

                    instance_types = set(provider_instance_types).intersection(instance_types)

paul@44

1465

                    module_types = set(provider_module_types).intersection(module_types)

                # Alias references a name, not an access.

                else:

paul@44

1470

                    # Attempt to refine the types using initialised names.

                    attr = self.get_initialised_name(access_location)

paul@44

1473

                    if attr:

paul@44

1474

                        (class_types, instance_types, module_types,

paul@57

1475

                            _function_types, _var_types) = separate_types([attr])

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

paul@44

1478

                    # refine the defined accessor types.

                    else:

paul@44

1481

                        return

                all_class_types.update(class_types)

paul@44

1484

                all_instance_types.update(instance_types)

paul@44

1485

                all_module_types.update(module_types)

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

            self.init_definition_details(accessor_location)

paul@44

1490

            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

1495

            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

1502

                    access_location = self.const_accesses[access_location]

                location, name, attrnames, access_number = access_location

                # Alias references an attribute access.

                if attrnames:

paul@44

1509

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

paul@44

1510

                    refs.update(attrs)

                # Alias references a name, not an access.

                else:

paul@44

1515

                    attr = self.get_initialised_name(access_location)

paul@44

1516

                    attrs = attr and [attr] or []

paul@44

1517

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

paul@44

1518

                        class_types = self.provider_class_types[access_location]

paul@44

1519

                        instance_types = self.provider_instance_types[access_location]

paul@44

1520

                        module_types = self.provider_module_types[access_location]

paul@57

1521

                        attrs = combine_types(class_types, instance_types, module_types)

paul@44

1522

                    if attrs:

paul@44

1523

                        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

1532

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

paul@44

1533

        None if no such references exist.

paul@44

1534

"""

        location, name, attrnames, version = access_location

paul@85

1537

        path = get_name_path(location, name)

        # Use initialiser information, if available.

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

paul@44

1542

        if refs and refs.has_key(version):

paul@44

1543

            return refs[version]

paul@44

1544

        else:

paul@44

1545

            return None

    def record_reference_types(self, location, class_types, instance_types,

paul@90

1548

        module_types, constrained, constrained_specific=False, invocations=None):

"""

paul@44

1551

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

paul@44

1552

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

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

paul@44

1555

        recorded for the location.

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

paul@44

1558

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

paul@44

1559

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

paul@44

1560

        to be a class.

        Note that the specified types only indicate the provider types for

paul@44

1563

        attributes, whereas the recorded accessor types indicate the possible

paul@44

1564

        types of the actual objects used to access attributes.

paul@44

1565

"""

        # Update the type details for the location.

        self.provider_class_types[location].update(class_types)

paul@44

1570

        self.provider_instance_types[location].update(instance_types)

paul@44

1571

        self.provider_module_types[location].update(module_types)

        # Class types support classes and instances as accessors.

paul@44

1574

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

paul@44

1575

        # accessors.

        path, name, version, attrnames = location

        if invocations:

paul@90

1580

            class_only_types = self.filter_for_invocations(class_types, invocations)

paul@90

1581

        else:

paul@90

1582

            class_only_types = class_types

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

paul@44

1585

        # Any self variable may only refer to an instance.

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

paul@90

1588

            self.accessor_class_types[location].update(class_only_types)

        if not constrained_specific:

paul@44

1591

            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

1596

            self.accessor_module_types[location].update(module_types)

        if constrained:

paul@67

1599

            self.accessor_constrained.add(location)

    def filter_for_invocations(self, class_types, attrnames):

"""

paul@90

1604

        From the given 'class_types', identify methods for the given

paul@90

1605

        'attrnames' that are being invoked, returning a filtered collection of

paul@90

1606

        class types.

paul@90

1607

"""

        to_filter = set()

        for class_type in class_types:

paul@90

1612

            for attrname in attrnames:

paul@90

1613

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

paul@90

1614

                parent_class = ref and ref.parent()

                if ref and ref.has_kind("<function>") and (

paul@90

1617

                   parent_class == class_type or

paul@90

1618

                   class_type in self.descendants[parent_class]):

                    to_filter.add(class_type)

paul@90

1621

                    break

        return set(class_types).difference(to_filter)

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

"""

paul@44

1628

        Identify reference attributes, associating them with the given

paul@44

1629

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

paul@44

1630

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

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

paul@44

1633

        recorded for the location.

paul@44

1634

"""

        # Record the referenced objects.

        self.referenced_attrs[location] = \

paul@44

1639

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

        if constrained:

paul@44

1642

            self.access_constrained.add(location)

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

"""

paul@44

1647

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

paul@44

1648

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

paul@44

1649

"""

        attrs = set()

        # The class types expose class attributes either directly or via

paul@44

1654

        # instances.

        for object_type in class_types:

paul@44

1657

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

paul@44

1658

            if ref:

paul@44

1659

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

            # Add any distinct instance attributes that would be provided

paul@44

1662

            # by instances also providing indirect class attribute access.

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

paul@44

1665

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

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

paul@44

1668

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

paul@44

1669

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

paul@44

1670

        # attributes.

        for object_type in instance_types:

paul@44

1673

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

            if instance_attrs:

paul@44

1676

                for ref in instance_attrs:

paul@44

1677

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

paul@44

1678

            else:

paul@44

1679

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

paul@44

1680

                if ref:

paul@44

1681

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

        # Module types expose module attributes for module accessors.

        for object_type in module_types:

paul@44

1686

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

paul@44

1687

            if ref:

paul@44

1688

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

        return attrs

    constrained_specific_tests = (

paul@70

1693

        "constrained-specific-instance",

paul@70

1694

        "constrained-specific-type",

paul@70

1695

        "constrained-specific-object",

    constrained_common_tests = (

paul@70

1699

        "constrained-common-instance",

paul@70

1700

        "constrained-common-type",

paul@70

1701

        "constrained-common-object",

    guarded_specific_tests = (

paul@67

1705

        "guarded-specific-instance",

paul@67

1706

        "guarded-specific-type",

paul@67

1707

        "guarded-specific-object",

    guarded_common_tests = (

paul@67

1711

        "guarded-common-instance",

paul@67

1712

        "guarded-common-type",

paul@67

1713

        "guarded-common-object",

    specific_tests = (

paul@67

1717

        "specific-instance",

paul@67

1718

        "specific-type",

paul@67

1719

        "specific-object",

    common_tests = (

paul@67

1723

        "common-instance",

paul@67

1724

        "common-type",

paul@67

1725

        "common-object",

    class_tests = (

paul@67

1729

        "guarded-specific-type",

paul@67

1730

        "guarded-common-type",

paul@67

1731

        "specific-type",

paul@67

1732

        "common-type",

    class_or_instance_tests = (

paul@67

1736

        "guarded-specific-object",

paul@67

1737

        "guarded-common-object",

paul@67

1738

        "specific-object",

paul@67

1739

        "common-object",

    def get_access_plan(self, location):

"""

paul@77

1745

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

paul@77

1746

        follows:

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

paul@77

1749

           computed static accessor is found)

paul@77

1750

         * details of any test required on the initial accessor

paul@77

1751

         * details of any type employed by the test

paul@77

1752

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

paul@77

1753

           preference to the initial accessor)

paul@77

1754

         * attributes needing to be traversed from the base that yield

paul@77

1755

           unambiguous objects

paul@77

1756

         * remaining attributes needing to be tested and traversed

paul@77

1757

         * details of the context

paul@77

1758

         * the method of obtaining the final attribute

paul@77

1759

         * any static final attribute

paul@77

1760

"""

        const_access = self.const_accesses_rev.has_key(location)

        path, name, attrnames, version = location

paul@75

1765

        remaining = attrnames.split(".")

paul@75

1766

        attrname = remaining[0]

        # Obtain reference and accessor information, retaining also distinct

paul@67

1769

        # provider kind details.

        attrs = []

paul@65

1772

        objtypes = []

paul@67

1773

        provider_kinds = set()

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

paul@65

1776

            attrs.append(attr)

paul@65

1777

            objtypes.append(objtype)

paul@67

1778

            provider_kinds.add(attrtype)

        # Obtain accessor type and kind information.

        accessor_types = self.reference_all_accessor_types[location]

paul@67

1783

        accessor_general_types = self.reference_all_accessor_general_types[location]

paul@67

1784

        accessor_kinds = get_kinds(accessor_general_types)

        # Determine any guard or test requirements.

        constrained = location in self.access_constrained

paul@70

1789

        test = self.reference_test_types[location]

paul@77

1790

        test_type = self.reference_test_accessor_type.get(location)

        # Determine the accessor and provider properties.

        class_accessor = "<class>" in accessor_kinds

paul@67

1795

        module_accessor = "<module>" in accessor_kinds

paul@67

1796

        instance_accessor = "<instance>" in accessor_kinds

paul@67

1797

        provided_by_class = "<class>" in provider_kinds

paul@67

1798

        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

1803

        class_relative = instance_accessor and provided_by_class

        # Identify the last static attribute for context acquisition.

        base = None

paul@67

1808

        dynamic_base = None

        # Constant accesses have static accessors.

        if const_access:

paul@65

1813

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

        # Constant accessors are static.

        else:

paul@65

1818

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

paul@67

1819

            if ref:

paul@65

1820

                base = ref.get_origin()

            # Usage of previously-generated guard and test details.

            elif test in self.constrained_specific_tests:

paul@67

1825

                ref = first(accessor_types)

            elif test in self.constrained_common_tests:

paul@67

1828

                ref = first(accessor_general_types)

            elif test in self.guarded_specific_tests:

paul@67

1831

                ref = first(accessor_types)

            elif test in self.guarded_common_tests:

paul@67

1834

                ref = first(accessor_general_types)

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

paul@70

1837

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

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

paul@77

1840

                dynamic_base = test_type

            # Static accessors.

            if not base and test in self.class_tests:

paul@70

1845

                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

1850

                dynamic_base = ref.get_origin()

        traversed = []

        # Traverse remaining attributes.

        while len(attrs) == 1:

paul@65

1857

            attr = first(attrs)

            traversed.append(attrname)

paul@75

1860

            del remaining[0]

            if not remaining:

paul@65

1863

                break

            # Update the last static attribute.

            if attr.static():

paul@65

1868

                base = attr.get_origin()

paul@65

1869

                traversed = []

            # Get the next attribute.

            attrname = remaining[0]

paul@65

1874

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

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

paul@67

1877

        # be loaded.

        else:

paul@65

1880

            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

1887

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

        # Static, identified attribute.

        elif attr and attr.static():

paul@67

1892

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

        # Attribute accessed at a known position via its parent.

        elif base or dynamic_base:

paul@74

1897

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

paul@74

1898

                                  (class_relative and "-class" or "")

paul@74

1899

            origin = None

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

        else:

paul@74

1904

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

paul@74

1905

                               (class_relative and "-class" or "")

paul@67

1906

            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