# vim: set ts=4 sw=4 tw=99 et:
# This Source Code Form is subject to the terms of the Mozilla Public
# License, v. 2.0. If a copy of the MPL was not distributed with this
# file, You can obtain one at http://mozilla.org/MPL/2.0/.

import os
import sys

from ipdl.ast import CxxInclude, Decl, Loc, QualifiedId, StructDecl
from ipdl.ast import UnionDecl, UsingStmt, Visitor, StringLiteral
from ipdl.ast import ASYNC, SYNC
from ipdl.ast import IN, OUT, INOUT
from ipdl.ast import NOT_NESTED, INSIDE_SYNC_NESTED, INSIDE_CPOW_NESTED
from ipdl.ast import priorityList
import ipdl.builtin as builtin
from ipdl.util import hash_str

# Used to get the list of Gecko process types
# xpcom/geckoprocesstypes_generator/geckoprocesstypes/__init__.py
import geckoprocesstypes

_DELETE_MSG = "__delete__"


class TypeVisitor:
    def __init__(self):
        self.visited = set()

    def defaultVisit(self, node, *args):
        raise Exception(
            "INTERNAL ERROR: no visitor for node type `%s'" % (node.__class__.__name__)
        )

    def visitVoidType(self, v, *args):
        pass

    def visitBuiltinCType(self, b, *args):
        pass

    def visitImportedCxxType(self, t, *args):
        pass

    def visitMessageType(self, m, *args):
        for param in m.params:
            param.accept(self, *args)
        for ret in m.returns:
            ret.accept(self, *args)
        if m.cdtype is not None:
            m.cdtype.accept(self, *args)

    def visitProtocolType(self, p, *args):
        # NB: don't visit manager and manages. a naive default impl
        # could result in an infinite loop
        pass

    def visitActorType(self, a, *args):
        a.protocol.accept(self, *args)

    def visitStructType(self, s, *args):
        if s in self.visited:
            return

        self.visited.add(s)
        for field in s.fields:
            field.accept(self, *args)

    def visitUnionType(self, u, *args):
        if u in self.visited:
            return

        self.visited.add(u)
        for component in u.components:
            component.accept(self, *args)

    def visitArrayType(self, a, *args):
        a.basetype.accept(self, *args)

    def visitMaybeType(self, m, *args):
        m.basetype.accept(self, *args)

    def visitUniquePtrType(self, m, *args):
        m.basetype.accept(self, *args)

    def visitNotNullType(self, m, *args):
        m.basetype.accept(self, *args)

    def visitShmemType(self, s, *args):
        pass

    def visitByteBufType(self, s, *args):
        pass

    def visitShmemChmodType(self, c, *args):
        c.shmem.accept(self)

    def visitFDType(self, s, *args):
        pass

    def visitEndpointType(self, s, *args):
        pass

    def visitManagedEndpointType(self, s, *args):
        pass


class Type:
    def __cmp__(self, o):
        return cmp(self.fullname(), o.fullname())

    def __eq__(self, o):
        return self.__class__ == o.__class__ and self.fullname() == o.fullname()

    def __hash__(self):
        return hash_str(self.fullname())

    # Is this a C++ type?
    def isCxx(self):
        return False

    # Is this an IPDL type?

    def isIPDL(self):
        return False

    # Is this type neither compound nor an array?

    def isAtom(self):
        return False

    def isRefcounted(self):
        return False

    # Should this type be wrapped in `NotNull<T>` unless marked `nullable`?

    def supportsNullable(self):
        return False

    def typename(self):
        return self.__class__.__name__

    def name(self):
        raise NotImplementedError()

    def fullname(self):
        raise NotImplementedError()

    def accept(self, visitor, *args):
        visit = getattr(visitor, "visit" + self.__class__.__name__, None)
        if visit is None:
            return getattr(visitor, "defaultVisit")(self, *args)
        return visit(self, *args)


class VoidType(Type):
    def isCxx(self):
        return True

    def isIPDL(self):
        return False

    def isAtom(self):
        return True

    def name(self):
        return "void"

    def fullname(self):
        return "void"


VOID = VoidType()

# --------------------


class BuiltinCType(Type):
    def __init__(self, name):
        self._name = name

    def isCxx(self):
        return True

    def isAtom(self):
        return True

    def isSendMoveOnly(self):
        return False

    def isDataMoveOnly(self):
        return False

    def name(self):
        return self._name

    def fullname(self):
        return self._name


class ImportedCxxType(Type):
    def __init__(self, qname, refcounted, sendmoveonly, datamoveonly):
        assert isinstance(qname, QualifiedId)
        self.loc = qname.loc
        self.qname = qname
        self.refcounted = refcounted
        self.sendmoveonly = sendmoveonly
        self.datamoveonly = datamoveonly

    def isCxx(self):
        return True

    def isAtom(self):
        return True

    def isRefcounted(self):
        return self.refcounted

    def supportsNullable(self):
        return self.refcounted

    def isSendMoveOnly(self):
        return self.sendmoveonly

    def isDataMoveOnly(self):
        return self.datamoveonly

    def name(self):
        return self.qname.baseid

    def fullname(self):
        return str(self.qname)


# --------------------


class IPDLType(Type):
    def isIPDL(self):
        return True

    def isMessage(self):
        return False

    def isProtocol(self):
        return False

    def isActor(self):
        return False

    def isStruct(self):
        return False

    def isUnion(self):
        return False

    def isArray(self):
        return False

    def isMaybe(self):
        return False

    def isUniquePtr(self):
        return False

    def isNotNull(self):
        return False

    def isAtom(self):
        return True

    def isCompound(self):
        return False

    def isShmem(self):
        return False

    def isByteBuf(self):
        return False

    def isFD(self):
        return False

    def isEndpoint(self):
        return False

    def isManagedEndpoint(self):
        return False

    def hasBaseType(self):
        return False


class SendSemanticsType(IPDLType):
    def __init__(self, nestedRange, sendSemantics):
        self.nestedRange = nestedRange
        self.sendSemantics = sendSemantics

    def isAsync(self):
        return self.sendSemantics == ASYNC

    def isSync(self):
        return self.sendSemantics == SYNC

    def sendSemanticsSatisfiedBy(self, greater):
        def _unwrap(nr):
            if isinstance(nr, dict):
                return _unwrap(nr["nested"])
            elif isinstance(nr, int):
                return nr
            else:
                raise ValueError("Got unexpected nestedRange value: %s" % nr)

        lesser = self
        lnr0, gnr0, lnr1, gnr1 = (
            _unwrap(lesser.nestedRange[0]),
            _unwrap(greater.nestedRange[0]),
            _unwrap(lesser.nestedRange[1]),
            _unwrap(greater.nestedRange[1]),
        )
        if lnr0 < gnr0 or lnr1 > gnr1:
            return False

        if lesser.isAsync():
            return True
        elif lesser.isSync() and not greater.isAsync():
            return True

        return False


class MessageType(SendSemanticsType):
    def __init__(
        self,
        nested,
        prio,
        replyPrio,
        sendSemantics,
        direction,
        ctor=False,
        dtor=False,
        cdtype=None,
        compress=False,
        tainted=False,
        lazySend=False,
    ):
        assert not (ctor and dtor)
        assert not (ctor or dtor) or cdtype is not None

        SendSemanticsType.__init__(self, (nested, nested), sendSemantics)
        self.nested = nested
        self.prio = prio
        self.replyPrio = replyPrio
        self.direction = direction
        self.params = []
        self.returns = []
        self.ctor = ctor
        self.dtor = dtor
        self.cdtype = cdtype
        self.compress = compress
        self.tainted = tainted
        self.lazySend = lazySend

    def isMessage(self):
        return True

    def isCtor(self):
        return self.ctor

    def isDtor(self):
        return self.dtor

    def constructedType(self):
        return self.cdtype

    def isIn(self):
        return self.direction is IN

    def isOut(self):
        return self.direction is OUT

    def isInout(self):
        return self.direction is INOUT

    def hasReply(self):
        return len(self.returns) or self.isSync()

    def hasImplicitActorParam(self):
        return self.isCtor()


class ProtocolType(SendSemanticsType):
    def __init__(self, qname, nested, sendSemantics, refcounted, needsotherpid):
        SendSemanticsType.__init__(self, (NOT_NESTED, nested), sendSemantics)
        self.qname = qname
        self.managers = []  # ProtocolType
        self.manages = []
        self.hasDelete = False
        self.refcounted = refcounted
        self.needsotherpid = needsotherpid

    def isProtocol(self):
        return True

    def isRefcounted(self):
        return self.refcounted

    def hasOtherPid(self):
        return all(top.needsotherpid for top in self.toplevels())

    def name(self):
        return self.qname.baseid

    def fullname(self):
        return str(self.qname)

    def addManager(self, mgrtype):
        assert mgrtype.isIPDL() and mgrtype.isProtocol()
        self.managers.append(mgrtype)

    def managedBy(self, mgr):
        self.managers = list(mgr)

    def toplevel(self):
        if self.isToplevel():
            return self
        for mgr in self.managers:
            if mgr is not self:
                return mgr.toplevel()

    def toplevels(self):
        if self.isToplevel():
            return [self]
        toplevels = list()
        for mgr in self.managers:
            if mgr is not self:
                toplevels.extend(mgr.toplevels())
        return set(toplevels)

    def isManagerOf(self, pt):
        for managed in self.manages:
            if pt is managed:
                return True
        return False

    def isManagedBy(self, pt):
        return pt in self.managers

    def isManager(self):
        return len(self.manages) > 0

    def isManaged(self):
        return 0 < len(self.managers)

    def isToplevel(self):
        return not self.isManaged()

    def manager(self):
        assert 1 == len(self.managers)
        for mgr in self.managers:
            return mgr


class ActorType(IPDLType):
    def __init__(self, protocol):
        self.protocol = protocol

    def isActor(self):
        return True

    def isRefcounted(self):
        return self.protocol.isRefcounted()

    def supportsNullable(self):
        return True

    def name(self):
        return self.protocol.name()

    def fullname(self):
        return self.protocol.fullname()


class _CompoundType(IPDLType):
    def __init__(self):
        self.defined = False  # bool
        self.mutualRec = set()  # set(_CompoundType | ArrayType)

    def isAtom(self):
        return False

    def isCompound(self):
        return True

    def itercomponents(self):
        raise Exception('"pure virtual" method')

    def mutuallyRecursiveWith(self, t, exploring=None):
        """|self| is mutually recursive with |t| iff |self| and |t|
        are in a cycle in the type graph rooted at |self|.  This function
        looks for such a cycle and returns True if found."""
        if exploring is None:
            exploring = set()

        if t.isAtom():
            return False
        elif t is self or t in self.mutualRec:
            return True
        elif t.hasBaseType():
            isrec = self.mutuallyRecursiveWith(t.basetype, exploring)
            if isrec:
                self.mutualRec.add(t)
            return isrec
        elif t in exploring:
            return False

        exploring.add(t)
        for c in t.itercomponents():
            if self.mutuallyRecursiveWith(c, exploring):
                self.mutualRec.add(c)
                return True
        exploring.remove(t)

        return False


class StructType(_CompoundType):
    def __init__(self, qname, fields):
        _CompoundType.__init__(self)
        self.qname = qname
        self.fields = fields  # [ Type ]

    def isStruct(self):
        return True

    def itercomponents(self):
        for f in self.fields:
            yield f

    def name(self):
        return self.qname.baseid

    def fullname(self):
        return str(self.qname)


class UnionType(_CompoundType):
    def __init__(self, qname, components):
        _CompoundType.__init__(self)
        self.qname = qname
        self.components = components  # [ Type ]

    def isUnion(self):
        return True

    def itercomponents(self):
        for c in self.components:
            yield c

    def name(self):
        return self.qname.baseid

    def fullname(self):
        return str(self.qname)


class ArrayType(IPDLType):
    def __init__(self, basetype):
        self.basetype = basetype

    def isAtom(self):
        return False

    def isArray(self):
        return True

    def hasBaseType(self):
        return True

    def name(self):
        return self.basetype.name() + "[]"

    def fullname(self):
        return self.basetype.fullname() + "[]"


class MaybeType(IPDLType):
    def __init__(self, basetype):
        self.basetype = basetype

    def isAtom(self):
        return False

    def isMaybe(self):
        return True

    def hasBaseType(self):
        return True

    def name(self):
        return self.basetype.name() + "?"

    def fullname(self):
        return self.basetype.fullname() + "?"


class ShmemType(IPDLType):
    def __init__(self, qname):
        self.qname = qname

    def isShmem(self):
        return True

    def name(self):
        return self.qname.baseid

    def fullname(self):
        return str(self.qname)


class ByteBufType(IPDLType):
    def __init__(self, qname):
        self.qname = qname

    def isByteBuf(self):
        return True

    def name(self):
        return self.qname.baseid

    def fullname(self):
        return str(self.qname)


class FDType(IPDLType):
    def __init__(self, qname):
        self.qname = qname

    def isFD(self):
        return True

    def name(self):
        return self.qname.baseid

    def fullname(self):
        return str(self.qname)


class EndpointType(IPDLType):
    def __init__(self, qname, actor):
        self.qname = qname
        self.actor = actor

    def isEndpoint(self):
        return True

    def name(self):
        return self.qname.baseid

    def fullname(self):
        return str(self.qname)


class ManagedEndpointType(IPDLType):
    def __init__(self, qname, actor):
        self.qname = qname
        self.actor = actor

    def isManagedEndpoint(self):
        return True

    def name(self):
        return self.qname.baseid

    def fullname(self):
        return str(self.qname)


class UniquePtrType(IPDLType):
    def __init__(self, basetype):
        self.basetype = basetype

    def isAtom(self):
        return False

    def isUniquePtr(self):
        return True

    def hasBaseType(self):
        return True

    def name(self):
        return "UniquePtr<" + self.basetype.name() + ">"

    def fullname(self):
        return "mozilla::UniquePtr<" + self.basetype.fullname() + ">"


class NotNullType(IPDLType):
    def __init__(self, basetype):
        self.basetype = basetype

    def isAtom(self):
        return False

    def isNotNull(self):
        return True

    def hasBaseType(self):
        return True

    def name(self):
        return "NotNull<" + self.basetype.name() + ">"

    def fullname(self):
        return "mozilla::NotNull<" + self.basetype.fullname() + ">"


def iteractortypes(t, visited=None):
    """Iterate over any actor(s) buried in |type|."""
    if visited is None:
        visited = set()

    # XXX |yield| semantics makes it hard to use TypeVisitor
    if not t.isIPDL():
        return
    elif t.isActor():
        yield t
    elif t.hasBaseType():
        for actor in iteractortypes(t.basetype, visited):
            yield actor
    elif t.isCompound() and t not in visited:
        visited.add(t)
        for c in t.itercomponents():
            for actor in iteractortypes(c, visited):
                yield actor


def hasshmem(type):
    """Return true iff |type| is shmem or has it buried within."""

    class found(BaseException):
        pass

    class findShmem(TypeVisitor):
        def visitShmemType(self, s):
            raise found()

    try:
        type.accept(findShmem())
    except found:
        return True
    return False


# --------------------
_builtinloc = Loc("<builtin>", 0)


def makeBuiltinUsing(tname):
    quals = tname.split("::")
    base = quals.pop()
    quals = quals[0:]
    return UsingStmt(_builtinloc, QualifiedId(_builtinloc, base, quals))


builtinUsing = [makeBuiltinUsing(t) for t in builtin.Types]
builtinHeaderIncludes = [CxxInclude(_builtinloc, f) for f in builtin.HeaderIncludes]


def errormsg(loc, fmt, *args):
    while not isinstance(loc, Loc):
        if loc is None:
            loc = Loc.NONE
        else:
            loc = loc.loc
    return "%s: error: %s" % (str(loc), fmt % args)


# --------------------


class SymbolTable:
    def __init__(self, errors):
        self.errors = errors
        self.scopes = [{}]  # stack({})
        self.currentScope = self.scopes[0]

    def enterScope(self):
        assert isinstance(self.scopes[0], dict)
        assert isinstance(self.currentScope, dict)

        self.scopes.append({})
        self.currentScope = self.scopes[-1]

    def exitScope(self):
        symtab = self.scopes.pop()
        assert self.currentScope is symtab

        self.currentScope = self.scopes[-1]

        assert isinstance(self.scopes[0], dict)
        assert isinstance(self.currentScope, dict)

    def lookup(self, sym):
        # NB: since IPDL doesn't allow any aliased names of different types,
        # it doesn't matter in which order we walk the scope chain to resolve
        # |sym|
        for scope in self.scopes:
            decl = scope.get(sym, None)
            if decl is not None:
                return decl
        return None

    def declare(self, decl):
        assert decl.progname or decl.shortname or decl.fullname
        assert decl.loc
        assert decl.type

        def tryadd(name):
            olddecl = self.lookup(name)
            if olddecl is not None:
                self.errors.append(
                    errormsg(
                        decl.loc,
                        "redeclaration of symbol `%s', first declared at %s",
                        name,
                        olddecl.loc,
                    )
                )
                return
            self.currentScope[name] = decl
            decl.scope = self.currentScope

        if decl.progname:
            tryadd(decl.progname)
        if decl.shortname:
            tryadd(decl.shortname)
        if decl.fullname:
            tryadd(decl.fullname)


class TypeCheck:
    """This pass sets the .decl attribute of AST nodes for which that is relevant;
    a decl says where, with what type, and under what name(s) a node was
    declared.

    With this information, it type checks the AST."""

    def __init__(self):
        # NB: no IPDL compile will EVER print a warning.  A program has
        # one of two attributes: it is either well typed, or not well typed.
        self.errors = []  # [ string ]

    def check(self, tu, errout=sys.stderr):
        def runpass(tcheckpass):
            tu.accept(tcheckpass)
            if len(self.errors):
                self.reportErrors(errout)
                return False
            return True

        # tag each relevant node with "decl" information, giving type, name,
        # and location of declaration
        if not runpass(GatherDecls(builtinUsing, self.errors)):
            return False

        # now that the nodes have decls, type checking is much easier.
        if not runpass(CheckTypes(self.errors)):
            return False

        return True

    def reportErrors(self, errout):
        for error in self.errors:
            print(error, file=errout)


class TcheckVisitor(Visitor):
    def __init__(self, errors):
        self.errors = errors

    def error(self, loc, fmt, *args):
        self.errors.append(errormsg(loc, fmt, *args))


class GatherDecls(TcheckVisitor):
    def __init__(self, builtinUsing, errors):
        TcheckVisitor.__init__(self, errors)

        # |self.symtab| is the symbol table for the translation unit
        # currently being visited
        self.symtab = None
        self.builtinUsing = builtinUsing

    def declare(
        self, loc, type, shortname=None, fullname=None, progname=None, attributes={}
    ):
        d = Decl(loc)
        d.type = type
        d.progname = progname
        d.shortname = shortname
        d.fullname = fullname
        d.attributes = attributes
        self.symtab.declare(d)
        return d

    # Check that only attributes allowed by an attribute spec are present
    # within the given attribute dictionary. The spec value may be either
    # `None`, for a valueless attribute, a list of valid attribute values, or a
    # callable which returns a truthy value if the attribute is valid.
    def checkAttributes(self, attributes, spec):
        for attr in attributes.values():
            if attr.name not in spec:
                self.error(attr.loc, "unknown attribute `%s'", attr.name)
                continue

            aspec = spec[attr.name]
            if aspec is None:
                if attr.value is not None:
                    self.error(
                        attr.loc,
                        "unexpected value for valueless attribute `%s'",
                        attr.name,
                    )
            elif isinstance(aspec, (list, tuple)):
                if not any(
                    (
                        isinstance(attr.value, s)
                        if isinstance(s, type)
                        else attr.value == s
                    )
                    for s in aspec
                ):
                    self.error(
                        attr.loc,
                        "invalid value for attribute `%s', expected one of: %s",
                        attr.name,
                        ", ".join(
                            s.__name__ if isinstance(s, type) else str(s) for s in aspec
                        ),
                    )
            elif callable(aspec):
                if not aspec(attr.value):
                    self.error(attr.loc, "invalid value for attribute `%s'", attr.name)
            else:
                raise Exception("INTERNAL ERROR: Invalid attribute spec")

    def visitTranslationUnit(self, tu):
        # all TranslationUnits declare symbols in global scope
        if hasattr(tu, "visited"):
            return
        tu.visited = True
        savedSymtab = self.symtab
        self.symtab = SymbolTable(self.errors)

        # pretend like the translation unit "using"-ed these for the
        # sake of type checking and C++ code generation
        tu.builtinUsing = self.builtinUsing

        # for everyone's sanity, enforce that the filename and tu name
        # match
        basefilename = os.path.basename(tu.filename)
        expectedfilename = "%s.ipdl" % (tu.name)
        if not tu.protocol:
            # header
            expectedfilename += "h"
        if basefilename != expectedfilename:
            self.error(
                tu.loc,
                "expected file for translation unit `%s' to be named `%s'; instead it's named `%s'",  # NOQA: E501
                tu.name,
                expectedfilename,
                basefilename,
            )

        if tu.protocol:
            assert tu.name == tu.protocol.name

            p = tu.protocol

            proc_options = [
                "any",
                "anychild",  # non-Parent process
                "anydom",  # Parent or Content process
                "compositor",  # Parent or GPU process
            ] + [p.proc_typename for p in geckoprocesstypes.process_types]

            self.checkAttributes(
                p.attributes,
                {
                    "ManualDealloc": None,
                    "NestedUpTo": ("not", "inside_sync", "inside_cpow"),
                    "NeedsOtherPid": None,
                    "ChildImpl": ("virtual", StringLiteral),
                    "ParentImpl": ("virtual", StringLiteral),
                    "ChildProc": proc_options,
                    "ParentProc": proc_options,
                },
            )

            # FIXME/cjones: it's a little weird and counterintuitive
            # to put both the namespace and non-namespaced name in the
            # global scope.  try to figure out something better; maybe
            # a type-neutral |using| that works for C++ and protocol
            # types?
            qname = p.qname()
            fullname = str(qname)
            p.decl = self.declare(
                loc=p.loc,
                type=ProtocolType(
                    qname,
                    p.nestedUpTo(),
                    p.sendSemantics,
                    "ManualDealloc" not in p.attributes,
                    "NeedsOtherPid" in p.attributes,
                ),
                shortname=p.name,
                fullname=fullname,
            )

            p.parentEndpointDecl = self.declare(
                loc=p.loc,
                type=EndpointType(
                    QualifiedId(
                        p.loc, "Endpoint<" + fullname + "Parent>", ["mozilla", "ipc"]
                    ),
                    ActorType(p.decl.type),
                ),
                shortname="Endpoint<" + p.name + "Parent>",
            )
            p.childEndpointDecl = self.declare(
                loc=p.loc,
                type=EndpointType(
                    QualifiedId(
                        p.loc, "Endpoint<" + fullname + "Child>", ["mozilla", "ipc"]
                    ),
                    ActorType(p.decl.type),
                ),
                shortname="Endpoint<" + p.name + "Child>",
            )

            p.parentManagedEndpointDecl = self.declare(
                loc=p.loc,
                type=ManagedEndpointType(
                    QualifiedId(
                        p.loc,
                        "ManagedEndpoint<" + fullname + "Parent>",
                        ["mozilla", "ipc"],
                    ),
                    ActorType(p.decl.type),
                ),
                shortname="ManagedEndpoint<" + p.name + "Parent>",
            )
            p.childManagedEndpointDecl = self.declare(
                loc=p.loc,
                type=ManagedEndpointType(
                    QualifiedId(
                        p.loc,
                        "ManagedEndpoint<" + fullname + "Child>",
                        ["mozilla", "ipc"],
                    ),
                    ActorType(p.decl.type),
                ),
                shortname="ManagedEndpoint<" + p.name + "Child>",
            )

            # XXX ugh, this sucks.  but we need this information to compute
            # what friend decls we need in generated C++
            p.decl.type._ast = p

        # make sure we have decls for all dependent protocols
        for pinc in tu.includes:
            pinc.accept(self)

        # declare imported (and builtin) C and C++ types
        for ctype in builtin.CTypes:
            self.declare(
                loc=_builtinloc,
                type=BuiltinCType(ctype),
                shortname=ctype,
            )
        for using in tu.builtinUsing:
            using.accept(self)
        for using in tu.using:
            using.accept(self)

        # first pass to "forward-declare" all structs and unions in
        # order to support recursive definitions
        for su in tu.structsAndUnions:
            self.declareStructOrUnion(su)

        # second pass to check each definition
        for su in tu.structsAndUnions:
            su.accept(self)

        if tu.protocol:
            # grab symbols in the protocol itself
            p.accept(self)

        self.symtab = savedSymtab

    def declareStructOrUnion(self, su):
        if hasattr(su, "decl"):
            self.symtab.declare(su.decl)
            return

        qname = su.qname()
        fullname = str(qname)

        if isinstance(su, StructDecl):
            sutype = StructType(qname, [])
        elif isinstance(su, UnionDecl):
            sutype = UnionType(qname, [])
        else:
            assert 0 and "unknown type"

        # XXX more suckage.  this time for pickling structs/unions
        # declared in headers.
        sutype._ast = su

        su.decl = self.declare(
            loc=su.loc, type=sutype, shortname=su.name, fullname=fullname
        )

    def visitInclude(self, inc):
        if inc.tu is None:
            self.error(
                inc.loc,
                "(type checking here will be unreliable because of an earlier error)",
            )
            return
        inc.tu.accept(self)
        if inc.tu.protocol:
            self.symtab.declare(inc.tu.protocol.decl)
            self.symtab.declare(inc.tu.protocol.parentEndpointDecl)
            self.symtab.declare(inc.tu.protocol.childEndpointDecl)
            self.symtab.declare(inc.tu.protocol.parentManagedEndpointDecl)
            self.symtab.declare(inc.tu.protocol.childManagedEndpointDecl)
        else:
            # This is a header.  Import its "exported" globals into
            # our scope.
            for using in inc.tu.using:
                using.accept(self)
            for su in inc.tu.structsAndUnions:
                self.declareStructOrUnion(su)

    def visitStructDecl(self, sd):
        # If we've already processed this struct, don't do it again.
        if hasattr(sd, "visited"):
            return

        stype = sd.decl.type

        self.symtab.enterScope()
        sd.visited = True

        self.checkAttributes(sd.attributes, {"Comparable": None})

        for f in sd.fields:
            ftypedecl = self.symtab.lookup(str(f.typespec))
            if ftypedecl is None:
                self.error(
                    f.loc,
                    "field `%s' of struct `%s' has unknown type `%s'",
                    f.name,
                    sd.name,
                    str(f.typespec),
                )
                continue

            f.decl = self.declare(
                loc=f.loc,
                type=self._canonicalType(ftypedecl.type, f.typespec),
                shortname=f.name,
                fullname=None,
            )
            stype.fields.append(f.decl.type)

        self.symtab.exitScope()

    def visitUnionDecl(self, ud):
        utype = ud.decl.type

        # If we've already processed this union, don't do it again.
        if len(utype.components):
            return

        self.checkAttributes(ud.attributes, {"Comparable": None})

        for c in ud.components:
            cdecl = self.symtab.lookup(str(c))
            if cdecl is None:
                self.error(
                    c.loc, "unknown component type `%s' of union `%s'", str(c), ud.name
                )
                continue
            utype.components.append(self._canonicalType(cdecl.type, c))

    def visitUsingStmt(self, using):
        fullname = str(using.type)

        self.checkAttributes(
            using.attributes,
            {
                "MoveOnly": (None, "data", "send"),
                "RefCounted": None,
            },
        )

        if fullname == "::mozilla::ipc::Shmem":
            ipdltype = ShmemType(using.type)
        elif fullname == "::mozilla::ipc::ByteBuf":
            ipdltype = ByteBufType(using.type)
        elif fullname == "::mozilla::ipc::FileDescriptor":
            ipdltype = FDType(using.type)
        else:
            ipdltype = ImportedCxxType(
                using.type,
                using.isRefcounted(),
                using.isSendMoveOnly(),
                using.isDataMoveOnly(),
            )
            existingType = self.symtab.lookup(ipdltype.fullname())
            if existingType and existingType.fullname == ipdltype.fullname():
                if ipdltype.isRefcounted() != existingType.type.isRefcounted():
                    self.error(
                        using.loc,
                        "inconsistent refcounted status of type `%s`",
                        str(using.type),
                    )
                if (
                    ipdltype.isSendMoveOnly() != existingType.type.isSendMoveOnly()
                    or ipdltype.isDataMoveOnly() != existingType.type.isDataMoveOnly()
                ):
                    self.error(
                        using.loc,
                        "inconsistent moveonly status of type `%s`",
                        str(using.type),
                    )
                using.decl = existingType
                return
        using.decl = self.declare(
            loc=using.loc,
            type=ipdltype,
            shortname=using.type.baseid,
            fullname=fullname,
        )

    def visitProtocol(self, p):
        # protocol scope
        self.symtab.enterScope()

        seenmgrs = set()
        for mgr in p.managers:
            if mgr.name in seenmgrs:
                self.error(mgr.loc, "manager `%s' appears multiple times", mgr.name)
                continue

            seenmgrs.add(mgr.name)
            mgr.of = p
            mgr.accept(self)

        for managed in p.managesStmts:
            managed.manager = p
            managed.accept(self)

        setattr(self, "currentProtocolDecl", p.decl)
        for msg in p.messageDecls:
            msg.accept(self)
        del self.currentProtocolDecl

        p.decl.type.hasDelete = not not self.symtab.lookup(_DELETE_MSG)
        if not (p.decl.type.hasDelete or p.decl.type.isToplevel()):
            self.error(
                p.loc,
                "destructor declaration `%s(...)' required for managed protocol `%s'",
                _DELETE_MSG,
                p.name,
            )

        if not p.decl.type.isToplevel() and p.decl.type.needsotherpid:
            self.error(p.loc, "[NeedsOtherPid] only applies to toplevel protocols")

        if p.decl.type.isToplevel():
            if not p.decl.type.isRefcounted():
                self.error(p.loc, "Toplevel protocols cannot be [ManualDealloc]")

            if "ChildProc" not in p.attributes:
                self.error(p.loc, "Toplevel protocols must specify [ChildProc]")

        if p.decl.type.isManager() and not p.decl.type.isRefcounted():
            self.error(p.loc, "[ManualDealloc] protocols cannot be managers")

        # FIXME/cjones declare all the little C++ thingies that will
        # be generated.  they're not relevant to IPDL itself, but
        # those ("invisible") symbols can clash with others in the
        # IPDL spec, and we'd like to catch those before C++ compilers
        # are allowed to obfuscate the error

        self.symtab.exitScope()

    def visitManager(self, mgr):
        mgrdecl = self.symtab.lookup(mgr.name)
        pdecl = mgr.of.decl
        assert pdecl

        pname, mgrname = pdecl.shortname, mgr.name
        loc = mgr.loc

        if mgrdecl is None:
            self.error(
                loc,
                "protocol `%s' referenced as |manager| of `%s' has not been declared",
                mgrname,
                pname,
            )
        elif not isinstance(mgrdecl.type, ProtocolType):
            self.error(
                loc,
                "entity `%s' referenced as |manager| of `%s' is not of `protocol' type; instead it is of type `%s'",  # NOQA: E501
                mgrname,
                pname,
                mgrdecl.type.typename(),
            )
        else:
            mgr.decl = mgrdecl
            pdecl.type.addManager(mgrdecl.type)

    def visitManagesStmt(self, mgs):
        mgsdecl = self.symtab.lookup(mgs.name)
        pdecl = mgs.manager.decl
        assert pdecl

        pname, mgsname = pdecl.shortname, mgs.name
        loc = mgs.loc

        if mgsdecl is None:
            self.error(
                loc,
                "protocol `%s', managed by `%s', has not been declared",
                mgsname,
                pname,
            )
        elif not isinstance(mgsdecl.type, ProtocolType):
            self.error(
                loc,
                "%s declares itself managing a non-`protocol' entity `%s' of type `%s'",
                pname,
                mgsname,
                mgsdecl.type.typename(),
            )
        else:
            mgs.decl = mgsdecl
            pdecl.type.manages.append(mgsdecl.type)

    def visitMessageDecl(self, md):
        msgname = md.name
        loc = md.loc

        self.checkAttributes(
            md.attributes,
            {
                "Tainted": None,
                "Compress": (None, "all"),
                "Priority": priorityList,
                "ReplyPriority": priorityList,
                "Nested": ("not", "inside_sync", "inside_cpow"),
                "VirtualSendImpl": None,
                "LazySend": None,
            },
        )

        if md.sendSemantics is not ASYNC and "LazySend" in md.attributes:
            self.error(loc, "non-async message `%s' cannot specify [LazySend]", msgname)

        if md.sendSemantics is not ASYNC and "ReplyPriority" in md.attributes:
            self.error(
                loc, "non-async message `%s' cannot specify [ReplyPriority]", msgname
            )

        if not md.outParams and "ReplyPriority" in md.attributes:
            self.error(
                loc, "non-returns message `%s' cannot specify [ReplyPriority]", msgname
            )

        isctor = False
        isdtor = False
        cdtype = None

        decl = self.symtab.lookup(msgname)
        if decl is not None and decl.type.isProtocol():
            # probably a ctor.  we'll check validity later.
            msgname += "Constructor"
            isctor = True
            cdtype = decl.type
        elif decl is not None:
            self.error(
                loc,
                "message name `%s' already declared as `%s'",
                msgname,
                decl.type.typename(),
            )
            # if we error here, no big deal; move on to find more

        if _DELETE_MSG == msgname:
            if md.sendSemantics is not ASYNC:
                self.error(loc, "destructor must be async")
            if md.outParams:
                self.error(loc, "destructors cannot return values")
            isdtor = True
            cdtype = self.currentProtocolDecl.type

        # enter message scope
        self.symtab.enterScope()

        msgtype = MessageType(
            nested=md.nested(),
            prio=md.priority(),
            replyPrio=md.replyPriority(),
            sendSemantics=md.sendSemantics,
            direction=md.direction,
            ctor=isctor,
            dtor=isdtor,
            cdtype=cdtype,
            compress=md.attributes.get("Compress"),
            tainted="Tainted" in md.attributes,
            lazySend="LazySend" in md.attributes,
        )

        # replace inparam Param nodes with proper Decls
        def paramToDecl(param):
            self.checkAttributes(
                param.attributes,
                {
                    # Passback indicates that the argument is unused by the Parent and is
                    #    merely returned to the Child later.
                    # AllValid indicates that the entire span of values representable by
                    #    the type are acceptable.  e.g. 0-255 in a uint8
                    "NoTaint": ("passback", "allvalid")
                },
            )

            ptname = param.typespec.basename()
            ploc = param.typespec.loc

            if "NoTaint" in param.attributes and "Tainted" not in md.attributes:
                self.error(
                    ploc,
                    "argument typename `%s' of message `%s' has a NoTaint attribute, but the message lacks the Tainted attribute",
                    ptname,
                    msgname,
                )

            ptdecl = self.symtab.lookup(ptname)
            if ptdecl is None:
                self.error(
                    ploc,
                    "argument typename `%s' of message `%s' has not been declared",
                    ptname,
                    msgname,
                )
                ptype = VOID
            else:
                ptype = self._canonicalType(ptdecl.type, param.typespec)
            return self.declare(
                loc=ploc, type=ptype, progname=param.name, attributes=param.attributes
            )

        for i, inparam in enumerate(md.inParams):
            pdecl = paramToDecl(inparam)
            msgtype.params.append(pdecl.type)
            md.inParams[i] = pdecl
        for i, outparam in enumerate(md.outParams):
            pdecl = paramToDecl(outparam)
            msgtype.returns.append(pdecl.type)
            md.outParams[i] = pdecl

        self.symtab.exitScope()

        md.decl = self.declare(loc=loc, type=msgtype, progname=msgname)
        md.protocolDecl = self.currentProtocolDecl
        md.decl._md = md

    def _canonicalType(self, itype, typespec):
        loc = typespec.loc
        if typespec.uniqueptr:
            itype = UniquePtrType(itype)

        if itype.isIPDL() and itype.isProtocol():
            itype = ActorType(itype)

        if itype.supportsNullable():
            if not typespec.nullable:
                itype = NotNullType(itype)
        elif typespec.nullable:
            self.error(
                loc, "`nullable' qualifier for type `%s' is unsupported", itype.name()
            )

        if typespec.array:
            itype = ArrayType(itype)

        if typespec.maybe:
            itype = MaybeType(itype)

        return itype


# -----------------------------------------------------------------------------


def checkcycles(p, stack=None):
    cycles = []

    if stack is None:
        stack = []

    for cp in p.manages:
        # special case for self-managed protocols
        if cp is p:
            continue

        if cp in stack:
            return [stack + [p, cp]]
        cycles += checkcycles(cp, stack + [p])

    return cycles


def formatcycles(cycles):
    r = []
    for cycle in cycles:
        s = " -> ".join([ptype.name() for ptype in cycle])
        r.append("`%s'" % s)
    return ", ".join(r)


def fullyDefined(t, exploring=None):
    """The rules for "full definition" of a type are
    defined(atom)             := true
    defined(array basetype)   := defined(basetype)
    defined(struct f1 f2...)  := defined(f1) and defined(f2) and ...
    defined(union c1 c2 ...)  := defined(c1) or defined(c2) or ..."""
    if exploring is None:
        exploring = set()

    if t.isAtom():
        return True
    elif t.hasBaseType():
        return fullyDefined(t.basetype, exploring)
    elif t.defined:
        return True
    assert t.isCompound()

    if t in exploring:
        return False

    exploring.add(t)
    for c in t.itercomponents():
        cdefined = fullyDefined(c, exploring)
        if t.isStruct() and not cdefined:
            t.defined = False
            break
        elif t.isUnion() and cdefined:
            t.defined = True
            break
    else:
        if t.isStruct():
            t.defined = True
        elif t.isUnion():
            t.defined = False
    exploring.remove(t)

    return t.defined


class CheckTypes(TcheckVisitor):
    def __init__(self, errors):
        TcheckVisitor.__init__(self, errors)
        self.visited = set()
        self.ptype = None

    def visitInclude(self, inc):
        if inc.tu.filename in self.visited:
            return
        self.visited.add(inc.tu.filename)
        if inc.tu.protocol:
            inc.tu.protocol.accept(self)

    def visitStructDecl(self, sd):
        if not fullyDefined(sd.decl.type):
            self.error(sd.decl.loc, "struct `%s' is only partially defined", sd.name)

    def visitUnionDecl(self, ud):
        if not fullyDefined(ud.decl.type):
            self.error(ud.decl.loc, "union `%s' is only partially defined", ud.name)

    def visitProtocol(self, p):
        self.ptype = p.decl.type

        # check that we require no more "power" than our manager protocols
        ptype, pname = p.decl.type, p.decl.shortname

        for mgrtype in ptype.managers:
            if mgrtype is not None and not ptype.sendSemanticsSatisfiedBy(mgrtype):
                self.error(
                    p.decl.loc,
                    "protocol `%s' requires more powerful send semantics than its manager `%s' provides",  # NOQA: E501
                    pname,
                    mgrtype.name(),
                )

        if ptype.isToplevel():
            cycles = checkcycles(p.decl.type)
            if cycles:
                self.error(
                    p.decl.loc,
                    "cycle(s) detected in manager/manages hierarchy: %s",
                    formatcycles(cycles),
                )

        if 1 == len(ptype.managers) and ptype is ptype.manager():
            self.error(
                p.decl.loc, "top-level protocol `%s' cannot manage itself", p.name
            )

        return Visitor.visitProtocol(self, p)

    def visitManagesStmt(self, mgs):
        pdecl = mgs.manager.decl
        ptype, pname = pdecl.type, pdecl.shortname

        mgsdecl = mgs.decl
        mgstype, mgsname = mgsdecl.type, mgsdecl.shortname

        loc = mgs.loc

        # we added this information; sanity check it
        assert ptype.isManagerOf(mgstype)

        # check that the "managed" protocol agrees
        if not mgstype.isManagedBy(ptype):
            self.error(
                loc,
                "|manages| declaration in protocol `%s' does not match any |manager| declaration in protocol `%s'",  # NOQA: E501
                pname,
                mgsname,
            )

    def visitManager(self, mgr):
        pdecl = mgr.of.decl
        ptype, pname = pdecl.type, pdecl.shortname

        mgrdecl = mgr.decl
        mgrtype, mgrname = mgrdecl.type, mgrdecl.shortname

        # we added this information; sanity check it
        assert ptype.isManagedBy(mgrtype)

        loc = mgr.loc

        # check that the "manager" protocol agrees
        if not mgrtype.isManagerOf(ptype):
            self.error(
                loc,
                "|manager| declaration in protocol `%s' does not match any |manages| declaration in protocol `%s'",  # NOQA: E501
                pname,
                mgrname,
            )

    def visitMessageDecl(self, md):
        mtype, mname = md.decl.type, md.decl.progname
        ptype, pname = md.protocolDecl.type, md.protocolDecl.shortname

        loc = md.decl.loc

        if mtype.nested == INSIDE_SYNC_NESTED and not mtype.isSync():
            self.error(
                loc,
                "inside_sync nested messages must be sync (here, message `%s' in protocol `%s')",
                mname,
                pname,
            )

        if mtype.nested == INSIDE_CPOW_NESTED and (mtype.isOut() or mtype.isInout()):
            self.error(
                loc,
                "inside_cpow nested parent-to-child messages are verboten (here, message `%s' in protocol `%s')",  # NOQA: E501
                mname,
                pname,
            )

        # We allow inside_sync messages that are themselves sync to be sent from the
        # parent. Normal and inside_cpow nested messages that are sync can only come from
        # the child.
        if (
            mtype.isSync()
            and mtype.nested == NOT_NESTED
            and (mtype.isOut() or mtype.isInout())
        ):
            self.error(
                loc,
                "sync parent-to-child messages are verboten (here, message `%s' in protocol `%s')",
                mname,
                pname,
            )

        if not mtype.sendSemanticsSatisfiedBy(ptype):
            self.error(
                loc,
                "message `%s' requires more powerful send semantics than its protocol `%s' provides",  # NOQA: E501
                mname,
                pname,
            )

        if (mtype.isCtor() or mtype.isDtor()) and mtype.isAsync() and mtype.returns:
            self.error(
                loc, "asynchronous ctor/dtor message `%s' declares return values", mname
            )

        if mtype.compress and (not mtype.isAsync() or mtype.isCtor() or mtype.isDtor()):
            if mtype.isCtor() or mtype.isDtor():
                message_type = "constructor" if mtype.isCtor() else "destructor"
                error_message = (
                    "%s messages can't use compression (here, in protocol `%s')"
                    % (message_type, pname)
                )
            else:
                error_message = (
                    "message `%s' in protocol `%s' requests compression but is not async"
                    % (mname, pname)  # NOQA: E501
                )

            self.error(loc, error_message)

        if mtype.isCtor() and not ptype.isManagerOf(mtype.constructedType()):
            self.error(
                loc,
                "ctor for protocol `%s', which is not managed by protocol `%s'",
                mname[: -len("constructor")],
                pname,
            )
