#!/usr/bin/env python

"""

Name resolution.

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

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

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

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

version.

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

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

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

details.

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

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

"""

from common import init_item

from results import AccessRef, InstanceRef, InvocationRef, LocalNameRef, \

                    MultipleRef, NameRef, ResolvedNameRef

from referencing import Reference

import sys

class NameResolving:

    "Resolving names mix-in for inspected modules."

    # Post-inspection resolution activities.

    def resolve(self):

        "Resolve dependencies and complete definitions."

        self.resolve_class_bases()

        self.check_special()

        self.check_names_used()

        self.check_invocations()

        self.resolve_initialisers()

        self.resolve_return_values()

        self.resolve_literals()

    def resolve_class_bases(self):

        "Resolve all class bases since some of them may have been deferred."

        for name, bases in self.classes.items():

            resolved = []

            bad = []

            for base in bases:

                ref = self.importer.identify(base.get_origin())

                # Obtain the origin of the base class reference.

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

                    bad.append(base)

                    break

                resolved.append(ref)

            if bad:

                print >>sys.stderr, "Bases of class %s were not classes: %s" % (name, ", ".join(map(str, bad)))

            else:

                self.importer.classes[name] = self.classes[name] = resolved

    def check_special(self):

        "Check special names."

        for name, value in self.special.items():

            ref, paths = value

            self.special[name] = self.importer.identify(ref.get_origin()), paths

    def check_names_used(self):

        "Check the external names used by each scope."

        for key, ref in self.name_references.items():

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

            self.resolve_accesses(path, name, ref)

    def check_invocations(self):

        "Find invocations amongst module data and replace their results."

        # Find members and replace invocation results with values. This is

        # effectively the same as is done for initialised names, but refers to

        # any unchanging value after initialisation.

        for key, ref in self.objects.items():

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

                ref = self.convert_invocation(ref)

                self.importer.objects[key] = self.objects[key] = ref

        # Convert name references.

        for key, ref in self.name_references.items():

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

                ref = self.convert_invocation(ref)

                self.importer.all_name_references[key] = self.name_references[key] = ref

        # Convert function defaults, which are effectively extra members of the

        # module, and function locals.

        for fname, parameters in self.function_defaults.items():

            l = []

            for pname, ref in parameters:

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

                    ref = self.convert_invocation(ref)

                l.append((pname, ref))

            self.importer.function_defaults[fname] = self.function_defaults[fname] = l

        # Convert function locals referencing invocations.

        for fname, names in self.function_locals.items():

            for name, ref in names.items():

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

                    ref = self.convert_invocation(ref)

                    names[name] = ref

    def convert_invocation(self, ref):

        "Convert the given invocation 'ref', handling instantiation."

        alias = ref.get_name()

        ref = self.importer.identify(ref.get_origin())

        ref = ref and ref.has_kind("<class>") and ref.instance_of() or Reference("<var>")

        return ref and ref.alias(alias) or None

    def resolve_accesses(self, path, name, ref):

        """

        Resolve any unresolved accesses in the function at the given 'path'

        for the given 'name' corresponding to the indicated 'ref'. Note that

        this mechanism cannot resolve things like inherited methods because

        they are not recorded as program objects in their inherited locations.

        """

        attr_accesses = self.global_attr_accesses.get(path)

        all_attrnames = attr_accesses and attr_accesses.get(name)

        if not all_attrnames:

            return

        # Insist on constant accessors.

        if not ref.has_kind(["<class>", "<module>"]):

            return

        found_attrnames = set()

        for attrnames in all_attrnames:

            # Start with the resolved name, adding attributes.

            attrs = ref.get_path()

            remaining = attrnames.split(".")

            last_ref = ref

            # Add each component, testing for a constant object.

            while remaining:

                attrname = remaining[0]

                attrs.append(attrname)

                del remaining[0]

                # Find any constant object reference.

                attr_ref = self.get_resolved_object(".".join(attrs))

                # Non-constant accessors terminate the traversal.

                if not attr_ref or not attr_ref.has_kind(["<class>", "<module>", "<function>"]):

                    # Provide the furthest constant accessor unless the final

                    # access can be resolved.

                    if remaining:

                        remaining.insert(0, attrs.pop())

                    else:

                        last_ref = attr_ref

                    break

                # Follow any reference to a constant object.

                # Where the given name refers to an object in another location,

                # switch to the other location in order to be able to test its

                # attributes.

                last_ref = attr_ref

                attrs = attr_ref.get_path()

            # Record a constant accessor only if an object was found

            # that is different from the namespace involved.

            if last_ref:

                objpath = ".".join(attrs)

                if objpath != path:

                    if last_ref.has_kind("<invoke>"):

                        last_ref = self.convert_invocation(last_ref)

                    # Establish a constant access.

                    init_item(self.const_accesses, path, dict)

                    self.const_accesses[path][(name, attrnames)] = (objpath, last_ref, ".".join(remaining))

                    if len(attrs) > 1:

                        found_attrnames.add(attrs[1])

        # Remove any usage records for the name.

        if found_attrnames:

            # NOTE: Should be only one name version.

            versions = []

            for version in self.attr_usage[path][name]:

                new_usage = set()

                for usage in version:

                    if found_attrnames.intersection(usage):

                        new_usage.add(tuple(set(usage).difference(found_attrnames)))

                    else:

                        new_usage.add(usage)

                versions.append(new_usage)

            self.attr_usage[path][name] = versions

    def resolve_initialisers(self):

        "Resolve initialiser values for names."

        # Get the initialisers in each namespace.

        for path, name_initialisers in self.name_initialisers.items():

            # Resolve values for each name in a scope.

            for name, values in name_initialisers.items():

                self._resolve_values(path, name, values)

    def resolve_return_values(self):

        "Resolve return values using name references."

        # Get the return values from each namespace.

        for path, values in self.return_values.items():

            # Resolve each return value provided by the scope.

            self._resolve_values(path, "$return", values)

    def _resolve_values(self, path, name, values):

        """

        Resolve in 'path' the references for 'name' involving the given

        'values'.

        """

        initialised_names = {}

        aliased_names = {}

        for i, name_ref in enumerate(values):

            initialised_ref, _aliased_names = self.resolve_reference(path, name_ref)

            if initialised_ref:

                initialised_names[i] = initialised_ref

            if _aliased_names:

                aliased_names[i] = _aliased_names

        if initialised_names:

            self.initialised_names[(path, name)] = initialised_names

        if aliased_names:

            self.aliased_names[(path, name)] = aliased_names

    def resolve_reference(self, path, name_ref):

        """

        Within the namespace 'path', resolve the given 'name_ref', returning any

        initialised reference, along with any aliased name information.

        """

        initialised_ref = None

        aliased_names = None

        no_reference = None, None

        # Attempt to obtain a coherent reference from multiple outcomes.

        if isinstance(name_ref, MultipleRef):

            refs = set()

            aliases = []

            for result in name_ref.results:

                _initialised_ref, _aliased_names = self.resolve_reference(path, result)

                # Unsuitable references at any level cause the result to yield

                # no reference.

                if not _initialised_ref:

                    refs = None

                elif refs is not None:

                    refs.add(_initialised_ref)

                if not _aliased_names:

                    aliases = None

                elif aliases is not None:

                    aliases += _aliased_names

            # Only unambiguous references are returned as initialising

            # references.

            if refs and len(refs) == 1:

                return list(refs)[0], aliases

            else:

                return None, aliases

        # Unwrap invocations.

        if isinstance(name_ref, InvocationRef):

            invocation = True

            name_ref = name_ref.name_ref

        else:

            invocation = False

        const_accesses = self.const_accesses.get(path)

        # Obtain a usable reference from names or constants.

        if isinstance(name_ref, ResolvedNameRef):

            if not name_ref.reference():

                return no_reference

            ref = name_ref.reference()

        # Obtain a reference from instances.

        elif isinstance(name_ref, InstanceRef):

            if not name_ref.reference():

                return no_reference

            ref = name_ref.reference()

        # Resolve accesses that employ constants.

        elif isinstance(name_ref, AccessRef):

            ref = None

            if const_accesses:

                resolved_access = const_accesses.get((name_ref.original_name, name_ref.attrnames))

                if resolved_access:

                    objpath, ref, remaining_attrnames = resolved_access

                    if remaining_attrnames:

                        ref = None

            # Accesses that do not employ constants cannot be resolved,

            # but they may be resolvable later.

            if not ref:

                # Record the path used for tracking purposes

                # alongside original name, attribute and access

                # number details.

                aliased_names = [(path, name_ref.original_name, name_ref.attrnames, name_ref.number)]

                return None, aliased_names

        # Attempt to resolve a plain name reference.

        elif isinstance(name_ref, LocalNameRef):

            key = "%s.%s" % (path, name_ref.name)

            ref = self.name_references.get(key)

            # Accesses that do not refer to known static objects

            # cannot be resolved, but they may be resolvable later.

            if not ref:

                # Record the path used for tracking purposes

                # alongside original name, attribute and access

                # number details.

                aliased_names = [(path, name_ref.name, None, name_ref.number)]

                return None, aliased_names

            ref = self.get_resolved_object(ref.get_origin())

            if not ref:

                return no_reference

        elif isinstance(name_ref, NameRef):

            key = "%s.%s" % (path, name_ref.name)

            ref = self.name_references.get(key)

            ref = ref and self.get_resolved_object(ref.get_origin())

            if not ref:

                return no_reference

        else:

            return no_reference

        # Resolve any hidden dependencies involving external objects

        # or unresolved names referring to globals or built-ins.

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

            ref = self.importer.identify(ref.get_origin())

        # Convert class invocations to instances.

        if ref and (invocation or ref.has_kind("<invoke>")):

            target_ref = ref

            ref = self.convert_invocation(target_ref)

            if not ref or ref.has_kind("<var>"):

                aliased_names = self.get_aliases_for_target(target_ref.get_origin())

            else:

                initialised_ref = ref

        elif ref and not ref.has_kind("<var>"):

            initialised_ref = ref

        return initialised_ref, aliased_names

    def get_aliases_for_target(self, path):

        "Return a list of return value locations for the given 'path'."

        return_values = self.importer.all_return_values.get(path)

        locations = []

        if return_values:

            for version in range(0, len(return_values)):

                locations.append((path, "$return", None, version))

        return locations

    def resolve_literals(self):

        "Resolve constant value types."

        # Get the constants defined in each namespace.

        for path, constants in self.constants.items():

            for constant, n in constants.items():

                objpath = "%s.$c%d" % (path, n)

                _constant, value_type, encoding = self.constant_values[objpath]

                self.initialised_names[(path, objpath)] = {0 : Reference("<instance>", value_type)}

        # Get the literals defined in each namespace.

        for path, literals in self.literals.items():

            for n in range(0, literals):

                objpath = "%s.$C%d" % (path, n)

                value_type = self.literal_types[objpath]

                self.initialised_names[(path, objpath)] = {0 : Reference("<instance>", value_type)}

    # Object resolution.

    def get_resolved_object(self, path, defer=False):

        """

        Get the details of an object with the given 'path' within this module.

        Where the object has not been resolved, None is returned. This differs

        from the get_object method used elsewhere in that it does not return an

        unresolved object reference.

        """

        if self.objects.has_key(path):

            ref = self.objects[path]

            if not defer and ref.has_kind("<depends>"):

                return None

            else:

                return ref

        else:

            return None

# vim: tabstop=4 expandtab shiftwidth=4