CodegenRust.py

# 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/.

# Common codegen classes.

from collections import defaultdict
from itertools import groupby

import operator
import os
import re
import string
import textwrap
import functools

from WebIDL import (
    BuiltinTypes,
    IDLBuiltinType,
    IDLNullValue,
    IDLType,
    IDLInterfaceMember,
    IDLUndefinedValue,
)

from Configuration import (
    MemberIsUnforgeable,
    getModuleFromObject,
    getTypesFromCallback,
    getTypesFromDescriptor,
    getTypesFromDictionary,
)

AUTOGENERATED_WARNING_COMMENT = \
    "/* THIS FILE IS AUTOGENERATED - DO NOT EDIT */\n\n"
FINALIZE_HOOK_NAME = '_finalize'
TRACE_HOOK_NAME = '_trace'
CONSTRUCT_HOOK_NAME = '_constructor'
HASINSTANCE_HOOK_NAME = '_hasInstance'

RUST_KEYWORDS = {"abstract", "alignof", "as", "become", "box", "break", "const", "continue",
                 "else", "enum", "extern", "false", "final", "fn", "for", "if", "impl", "in",
                 "let", "loop", "macro", "match", "mod", "move", "mut", "offsetof", "override",
                 "priv", "proc", "pub", "pure", "ref", "return", "static", "self", "sizeof",
                 "struct", "super", "true", "trait", "type", "typeof", "unsafe", "unsized",
                 "use", "virtual", "where", "while", "yield"}


def replaceFileIfChanged(filename, newContents):
    """
    Read a copy of the old file, so that we don't touch it if it hasn't changed.
    Returns True if the file was updated, false otherwise.
    """
    # XXXjdm This doesn't play well with make right now.
    #       Force the file to always be updated, or else changing CodegenRust.py
    #       will cause many autogenerated bindings to be regenerated perpetually
    #       until the result is actually different.

    # oldFileContents = ""
    # try:
    #     with open(filename, 'rb') as oldFile:
    #         oldFileContents = ''.join(oldFile.readlines())
    # except:
    #     pass

    # if newContents == oldFileContents:
    #     return False

    with open(filename, 'wb') as f:
        f.write(newContents)

    return True


def toStringBool(arg):
    return str(not not arg).lower()


def toBindingNamespace(arg):
    return re.sub("((_workers)?$)", "Binding\\1", arg)


def stripTrailingWhitespace(text):
    tail = '\n' if text.endswith('\n') else ''
    lines = text.splitlines()
    for i in range(len(lines)):
        lines[i] = lines[i].rstrip()
    return '\n'.join(lines) + tail


def innerSequenceType(type):
    assert type.isSequence()
    return type.inner.inner if type.nullable() else type.inner


def MakeNativeName(name):
    return name[0].upper() + name[1:]

builtinNames = {
    IDLType.Tags.bool: 'bool',
    IDLType.Tags.int8: 'i8',
    IDLType.Tags.int16: 'i16',
    IDLType.Tags.int32: 'i32',
    IDLType.Tags.int64: 'i64',
    IDLType.Tags.uint8: 'u8',
    IDLType.Tags.uint16: 'u16',
    IDLType.Tags.uint32: 'u32',
    IDLType.Tags.uint64: 'u64',
    IDLType.Tags.unrestricted_float: 'f32',
    IDLType.Tags.float: 'Finite<f32>',
    IDLType.Tags.unrestricted_double: 'f64',
    IDLType.Tags.double: 'Finite<f64>'
}

numericTags = [
    IDLType.Tags.int8, IDLType.Tags.uint8,
    IDLType.Tags.int16, IDLType.Tags.uint16,
    IDLType.Tags.int32, IDLType.Tags.uint32,
    IDLType.Tags.int64, IDLType.Tags.uint64,
    IDLType.Tags.unrestricted_float,
    IDLType.Tags.unrestricted_double
]


def unwrapCastableObject(descriptor, source, codeOnFailure, conversionFunction):
    """
    A function for unwrapping an object named by the "source" argument
    based on the passed-in descriptor. Returns the string of the Rust expression of
    the appropriate type.

    codeOnFailure is the code to run if unwrapping fails.
    """
    args = {
        "failureCode": CGIndenter(CGGeneric(codeOnFailure), 8).define(),
        "function": conversionFunction,
        "source": source,
    }
    return """\
match %(function)s(%(source)s) {
    Ok(val) => val,
    Err(()) => {
%(failureCode)s
    }
}""" % args


# We'll want to insert the indent at the beginnings of lines, but we
# don't want to indent empty lines.  So only indent lines that have a
# non-newline character on them.
lineStartDetector = re.compile("^(?=[^\n#])", re.MULTILINE)


def indent(s, indentLevel=2):
    """
    Indent C++ code.

    Weird secret feature: this doesn't indent lines that start with # (such as
    #include lines or #ifdef/#endif).
    """
    if s == "":
        return s
    return re.sub(lineStartDetector, indentLevel * " ", s)


# dedent() and fill() are often called on the same string multiple
# times.  We want to memoize their return values so we don't keep
# recomputing them all the time.
def memoize(fn):
    """
    Decorator to memoize a function of one argument.  The cache just
    grows without bound.
    """
    cache = {}

    @functools.wraps(fn)
    def wrapper(arg):
        retval = cache.get(arg)
        if retval is None:
            retval = cache[arg] = fn(arg)
        return retval
    return wrapper


@memoize
def dedent(s):
    """
    Remove all leading whitespace from s, and remove a blank line
    at the beginning.
    """
    if s.startswith('\n'):
        s = s[1:]
    return textwrap.dedent(s)


# This works by transforming the fill()-template to an equivalent
# string.Template.
fill_multiline_substitution_re = re.compile(r"( *)\$\*{(\w+)}(\n)?")


@memoize
def compile_fill_template(template):
    """
    Helper function for fill().  Given the template string passed to fill(),
    do the reusable part of template processing and return a pair (t,
    argModList) that can be used every time fill() is called with that
    template argument.

    argsModList is list of tuples that represent modifications to be
    made to args.  Each modification has, in order: i) the arg name,
    ii) the modified name, iii) the indent depth.
    """
    t = dedent(template)
    assert t.endswith("\n") or "\n" not in t
    argModList = []

    def replace(match):
        """
        Replaces a line like '  $*{xyz}\n' with '${xyz_n}',
        where n is the indent depth, and add a corresponding entry to
        argModList.

        Note that this needs to close over argModList, so it has to be
        defined inside compile_fill_template().
        """
        indentation, name, nl = match.groups()
        depth = len(indentation)

        # Check that $*{xyz} appears by itself on a line.
        prev = match.string[:match.start()]
        if (prev and not prev.endswith("\n")) or nl is None:
            raise ValueError("Invalid fill() template: $*{%s} must appear by itself on a line" % name)

        # Now replace this whole line of template with the indented equivalent.
        modified_name = name + "_" + str(depth)
        argModList.append((name, modified_name, depth))
        return "${" + modified_name + "}"

    t = re.sub(fill_multiline_substitution_re, replace, t)
    return (string.Template(t), argModList)


def fill(template, **args):
    """
    Convenience function for filling in a multiline template.

    `fill(template, name1=v1, name2=v2)` is a lot like
    `string.Template(template).substitute({"name1": v1, "name2": v2})`.

    However, it's shorter, and has a few nice features:

      * If `template` is indented, fill() automatically dedents it!
        This makes code using fill() with Python's multiline strings
        much nicer to look at.

      * If `template` starts with a blank line, fill() strips it off.
        (Again, convenient with multiline strings.)

      * fill() recognizes a special kind of substitution
        of the form `$*{name}`.

        Use this to paste in, and automatically indent, multiple lines.
        (Mnemonic: The `*` is for "multiple lines").

        A `$*` substitution must appear by itself on a line, with optional
        preceding indentation (spaces only). The whole line is replaced by the
        corresponding keyword argument, indented appropriately.  If the
        argument is an empty string, no output is generated, not even a blank
        line.
    """

    t, argModList = compile_fill_template(template)
    # Now apply argModList to args
    for (name, modified_name, depth) in argModList:
        if not (args[name] == "" or args[name].endswith("\n")):
            raise ValueError("Argument %s with value %r is missing a newline" % (name, args[name]))
        args[modified_name] = indent(args[name], depth)

    return t.substitute(args)


class CGThing():
    """
    Abstract base class for things that spit out code.
    """
    def __init__(self):
        pass  # Nothing for now

    def define(self):
        """Produce code for a Rust file."""
        raise NotImplementedError  # Override me!


class CGMethodCall(CGThing):
    """
    A class to generate selection of a method signature from a set of
    signatures and generation of a call to that signature.
    """
    def __init__(self, argsPre, nativeMethodName, static, descriptor, method):
        CGThing.__init__(self)

        methodName = '\\"%s.%s\\"' % (descriptor.interface.identifier.name, method.identifier.name)

        def requiredArgCount(signature):
            arguments = signature[1]
            if len(arguments) == 0:
                return 0
            requiredArgs = len(arguments)
            while requiredArgs and arguments[requiredArgs - 1].optional:
                requiredArgs -= 1
            return requiredArgs

        signatures = method.signatures()

        def getPerSignatureCall(signature, argConversionStartsAt=0):
            signatureIndex = signatures.index(signature)
            return CGPerSignatureCall(signature[0], argsPre, signature[1],
                                      nativeMethodName + '_' * signatureIndex,
                                      static, descriptor,
                                      method, argConversionStartsAt)

        if len(signatures) == 1:
            # Special case: we can just do a per-signature method call
            # here for our one signature and not worry about switching
            # on anything.
            signature = signatures[0]
            self.cgRoot = CGList([getPerSignatureCall(signature)])
            requiredArgs = requiredArgCount(signature)

            if requiredArgs > 0:
                code = (
                    "if argc < %d {\n"
                    "    throw_type_error(cx, \"Not enough arguments to %s.\");\n"
                    "    return false;\n"
                    "}" % (requiredArgs, methodName))
                self.cgRoot.prepend(
                    CGWrapper(CGGeneric(code), pre="\n", post="\n"))

            return

        # Need to find the right overload
        maxArgCount = method.maxArgCount
        allowedArgCounts = method.allowedArgCounts

        argCountCases = []
        for argCount in allowedArgCounts:
            possibleSignatures = method.signaturesForArgCount(argCount)
            if len(possibleSignatures) == 1:
                # easy case!
                signature = possibleSignatures[0]
                argCountCases.append(CGCase(str(argCount), getPerSignatureCall(signature)))
                continue

            distinguishingIndex = method.distinguishingIndexForArgCount(argCount)

            # We can't handle unions at the distinguishing index.
            for (returnType, args) in possibleSignatures:
                if args[distinguishingIndex].type.isUnion():
                    raise TypeError("No support for unions as distinguishing "
                                    "arguments yet: %s",
                                    args[distinguishingIndex].location)

            # Convert all our arguments up to the distinguishing index.
            # Doesn't matter which of the possible signatures we use, since
            # they all have the same types up to that point; just use
            # possibleSignatures[0]
            caseBody = [
                CGArgumentConverter(possibleSignatures[0][1][i],
                                    i, "args", "argc", descriptor)
                for i in range(0, distinguishingIndex)]

            # Select the right overload from our set.
            distinguishingArg = "args.get(%d)" % distinguishingIndex

            def pickFirstSignature(condition, filterLambda):
                sigs = filter(filterLambda, possibleSignatures)
                assert len(sigs) < 2
                if len(sigs) > 0:
                    call = getPerSignatureCall(sigs[0], distinguishingIndex)
                    if condition is None:
                        caseBody.append(call)
                    else:
                        caseBody.append(CGGeneric("if " + condition + " {"))
                        caseBody.append(CGIndenter(call))
                        caseBody.append(CGGeneric("}"))
                    return True
                return False

            # First check for null or undefined
            pickFirstSignature("%s.isNullOrUndefined()" % distinguishingArg,
                               lambda s: (s[1][distinguishingIndex].type.nullable() or
                                          s[1][distinguishingIndex].type.isDictionary()))

            # Now check for distinguishingArg being an object that implements a
            # non-callback interface.  That includes typed arrays and
            # arraybuffers.
            interfacesSigs = [
                s for s in possibleSignatures
                if (s[1][distinguishingIndex].type.isObject() or
                    s[1][distinguishingIndex].type.isNonCallbackInterface())]
            # There might be more than one of these; we need to check
            # which ones we unwrap to.

            if len(interfacesSigs) > 0:
                # The spec says that we should check for "platform objects
                # implementing an interface", but it's enough to guard on these
                # being an object.  The code for unwrapping non-callback
                # interfaces and typed arrays will just bail out and move on to
                # the next overload if the object fails to unwrap correctly.  We
                # could even not do the isObject() check up front here, but in
                # cases where we have multiple object overloads it makes sense
                # to do it only once instead of for each overload.  That will
                # also allow the unwrapping test to skip having to do codegen
                # for the null-or-undefined case, which we already handled
                # above.
                caseBody.append(CGGeneric("if %s.get().is_object() {" %
                                          (distinguishingArg)))
                for idx, sig in enumerate(interfacesSigs):
                    caseBody.append(CGIndenter(CGGeneric("loop {")))
                    type = sig[1][distinguishingIndex].type

                    # The argument at index distinguishingIndex can't possibly
                    # be unset here, because we've already checked that argc is
                    # large enough that we can examine this argument.
                    info = getJSToNativeConversionInfo(
                        type, descriptor, failureCode="break;", isDefinitelyObject=True)
                    template = info.template
                    declType = info.declType

                    testCode = instantiateJSToNativeConversionTemplate(
                        template,
                        {"val": distinguishingArg},
                        declType,
                        "arg%d" % distinguishingIndex)

                    # Indent by 4, since we need to indent further than our "do" statement
                    caseBody.append(CGIndenter(testCode, 4))
                    # If we got this far, we know we unwrapped to the right
                    # interface, so just do the call.  Start conversion with
                    # distinguishingIndex + 1, since we already converted
                    # distinguishingIndex.
                    caseBody.append(CGIndenter(
                        getPerSignatureCall(sig, distinguishingIndex + 1), 4))
                    caseBody.append(CGIndenter(CGGeneric("}")))

                caseBody.append(CGGeneric("}"))

            # XXXbz Now we're supposed to check for distinguishingArg being
            # an array or a platform object that supports indexed
            # properties... skip that last for now.  It's a bit of a pain.
            pickFirstSignature("%s.get().is_object() && is_array_like(cx, %s)" %
                               (distinguishingArg, distinguishingArg),
                               lambda s:
                                   (s[1][distinguishingIndex].type.isArray() or
                                    s[1][distinguishingIndex].type.isSequence() or
                                    s[1][distinguishingIndex].type.isObject()))

            # Check for Date objects
            # XXXbz Do we need to worry about security wrappers around the Date?
            pickFirstSignature("%s.get().is_object() && JS_ObjectIsDate(cx, &%s.get().to_object())" %
                               (distinguishingArg, distinguishingArg),
                               lambda s: (s[1][distinguishingIndex].type.isDate() or
                                          s[1][distinguishingIndex].type.isObject()))

            # Check for vanilla JS objects
            # XXXbz Do we need to worry about security wrappers?
            pickFirstSignature("%s.get().is_object() && !is_platform_object(%s.get().to_object())" %
                               (distinguishingArg, distinguishingArg),
                               lambda s: (s[1][distinguishingIndex].type.isCallback() or
                                          s[1][distinguishingIndex].type.isCallbackInterface() or
                                          s[1][distinguishingIndex].type.isDictionary() or
                                          s[1][distinguishingIndex].type.isObject()))

            # The remaining cases are mutually exclusive.  The
            # pickFirstSignature calls are what change caseBody
            # Check for strings or enums
            if pickFirstSignature(None,
                                  lambda s: (s[1][distinguishingIndex].type.isString() or
                                             s[1][distinguishingIndex].type.isEnum())):
                pass
            # Check for primitives
            elif pickFirstSignature(None,
                                    lambda s: s[1][distinguishingIndex].type.isPrimitive()):
                pass
            # Check for "any"
            elif pickFirstSignature(None,
                                    lambda s: s[1][distinguishingIndex].type.isAny()):
                pass
            else:
                # Just throw; we have no idea what we're supposed to
                # do with this.
                caseBody.append(CGGeneric("return Throw(cx, NS_ERROR_XPC_BAD_CONVERT_JS);"))

            argCountCases.append(CGCase(str(argCount),
                                        CGList(caseBody, "\n")))

        overloadCGThings = []
        overloadCGThings.append(
            CGGeneric("let argcount = cmp::min(argc, %d);" %
                      maxArgCount))
        overloadCGThings.append(
            CGSwitch("argcount",
                     argCountCases,
                     CGGeneric("throw_type_error(cx, \"Not enough arguments to %s.\");\n"
                               "return false;" % methodName)))
        # XXXjdm Avoid unreachable statement warnings
        # overloadCGThings.append(
        #     CGGeneric('panic!("We have an always-returning default case");\n'
        #               'return false;'))
        self.cgRoot = CGWrapper(CGList(overloadCGThings, "\n"),
                                pre="\n")

    def define(self):
        return self.cgRoot.define()


def dictionaryHasSequenceMember(dictionary):
    return (any(typeIsSequenceOrHasSequenceMember(m.type) for m in
                dictionary.members) or
            (dictionary.parent and
             dictionaryHasSequenceMember(dictionary.parent)))


def typeIsSequenceOrHasSequenceMember(type):
    if type.nullable():
        type = type.inner
    if type.isSequence():
        return True
    if type.isArray():
        elementType = type.inner
        return typeIsSequenceOrHasSequenceMember(elementType)
    if type.isDictionary():
        return dictionaryHasSequenceMember(type.inner)
    if type.isUnion():
        return any(typeIsSequenceOrHasSequenceMember(m.type) for m in
                   type.flatMemberTypes)
    return False


def typeNeedsRooting(type, descriptorProvider):
    return (type.isGeckoInterface() and
            descriptorProvider.getDescriptor(type.unroll().inner.identifier.name).needsRooting)


def union_native_type(t):
    name = t.unroll().name
    return 'UnionTypes::%s' % name


class JSToNativeConversionInfo():
    """
    An object representing information about a JS-to-native conversion.
    """
    def __init__(self, template, default=None, declType=None,
                 needsRooting=False):
        """
        template: A string representing the conversion code.  This will have
                  template substitution performed on it as follows:

          ${val} is a handle to the JS::Value in question

        default: A string or None representing rust code for default value(if any).

        declType: A CGThing representing the native C++ type we're converting
                  to.  This is allowed to be None if the conversion code is
                  supposed to be used as-is.

        needsRooting: A boolean indicating whether the caller has to root
                      the result
        """
        assert isinstance(template, str)
        assert declType is None or isinstance(declType, CGThing)
        self.template = template
        self.default = default
        self.declType = declType
        self.needsRooting = needsRooting


def getJSToNativeConversionInfo(type, descriptorProvider, failureCode=None,
                                isDefinitelyObject=False,
                                isMember=False,
                                isArgument=False,
                                invalidEnumValueFatal=True,
                                defaultValue=None,
                                treatNullAs="Default",
                                isEnforceRange=False,
                                isClamp=False,
                                exceptionCode=None,
                                allowTreatNonObjectAsNull=False,
                                isCallbackReturnValue=False,
                                sourceDescription="value"):
    """
    Get a template for converting a JS value to a native object based on the
    given type and descriptor.  If failureCode is given, then we're actually
    testing whether we can convert the argument to the desired type.  That
    means that failures to convert due to the JS value being the wrong type of
    value need to use failureCode instead of throwing exceptions.  Failures to
    convert that are due to JS exceptions (from toString or valueOf methods) or
    out of memory conditions need to throw exceptions no matter what
    failureCode is.

    If isDefinitelyObject is True, that means we know the value
    isObject() and we have no need to recheck that.

    if isMember is True, we're being converted from a property of some
    JS object, not from an actual method argument, so we can't rely on
    our jsval being rooted or outliving us in any way.  Any caller
    passing true needs to ensure that it is handled correctly in
    typeIsSequenceOrHasSequenceMember.

    invalidEnumValueFatal controls whether an invalid enum value conversion
    attempt will throw (if true) or simply return without doing anything (if
    false).

    If defaultValue is not None, it's the IDL default value for this conversion

    If isEnforceRange is true, we're converting an integer and throwing if the
    value is out of range.

    If isClamp is true, we're converting an integer and clamping if the
    value is out of range.

    If allowTreatNonObjectAsNull is true, then [TreatNonObjectAsNull]
    extended attributes on nullable callback functions will be honored.

    The return value from this function is an object of JSToNativeConversionInfo consisting of four things:

    1)  A string representing the conversion code.  This will have template
        substitution performed on it as follows:

          ${val} replaced by an expression for the JS::Value in question

    2)  A string or None representing Rust code for the default value (if any).

    3)  A CGThing representing the native C++ type we're converting to
        (declType).  This is allowed to be None if the conversion code is
        supposed to be used as-is.

    4)  A boolean indicating whether the caller has to root the result.

    """
    # We should not have a defaultValue if we know we're an object
    assert not isDefinitelyObject or defaultValue is None

    # If exceptionCode is not set, we'll just rethrow the exception we got.
    # Note that we can't just set failureCode to exceptionCode, because setting
    # failureCode will prevent pending exceptions from being set in cases when
    # they really should be!
    if exceptionCode is None:
        exceptionCode = "return false;"

    needsRooting = typeNeedsRooting(type, descriptorProvider)

    def handleOptional(template, declType, default):
        assert (defaultValue is None) == (default is None)
        return JSToNativeConversionInfo(template, default, declType, needsRooting=needsRooting)

    # Unfortunately, .capitalize() on a string will lowercase things inside the
    # string, which we do not want.
    def firstCap(string):
        return string[0].upper() + string[1:]

    # Helper functions for dealing with failures due to the JS value being the
    # wrong type of value.
    def onFailureNotAnObject(failureCode):
        return CGWrapper(
            CGGeneric(
                failureCode or
                ('throw_type_error(cx, "%s is not an object.");\n'
                 '%s' % (firstCap(sourceDescription), exceptionCode))),
            post="\n")

    def onFailureInvalidEnumValue(failureCode, passedVarName):
        return CGGeneric(
            failureCode or
            ('throw_type_error(cx, &format!("\'{}\' is not a valid enum value for enumeration \'%s\'.", %s)); %s'
             % (type.name, passedVarName, exceptionCode)))

    def onFailureNotCallable(failureCode):
        return CGGeneric(
            failureCode or
            ('throw_type_error(cx, \"%s is not callable.\");\n'
             '%s' % (firstCap(sourceDescription), exceptionCode)))

    # A helper function for handling null default values. Checks that the
    # default value, if it exists, is null.
    def handleDefaultNull(nullValue):
        if defaultValue is None:
            return None

        if not isinstance(defaultValue, IDLNullValue):
            raise TypeError("Can't handle non-null default value here")

        assert type.nullable() or type.isDictionary()
        return nullValue

    # A helper function for wrapping up the template body for
    # possibly-nullable objecty stuff
    def wrapObjectTemplate(templateBody, nullValue, isDefinitelyObject, type,
                           failureCode=None):
        if not isDefinitelyObject:
            # Handle the non-object cases by wrapping up the whole
            # thing in an if cascade.
            templateBody = (
                "if ${val}.get().is_object() {\n" +
                CGIndenter(CGGeneric(templateBody)).define() + "\n")
            if type.nullable():
                templateBody += (
                    "} else if ${val}.get().is_null_or_undefined() {\n"
                    "    %s\n") % nullValue
            templateBody += (
                "} else {\n" +
                CGIndenter(onFailureNotAnObject(failureCode)).define() +
                "}")
        return templateBody

    assert not (isEnforceRange and isClamp)  # These are mutually exclusive

    if type.isArray():
        raise TypeError("Can't handle array arguments yet")

    if type.isSequence():
        innerInfo = getJSToNativeConversionInfo(innerSequenceType(type), descriptorProvider)
        declType = CGWrapper(innerInfo.declType, pre="Vec<", post=">")
        config = getConversionConfigForType(type, isEnforceRange, isClamp, treatNullAs)

        if type.nullable():
            declType = CGWrapper(declType, pre="Option<", post=" >")

        templateBody = ("match FromJSValConvertible::from_jsval(cx, ${val}, %s) {\n"
                        "    Ok(value) => value,\n"
                        "    Err(()) => { %s },\n"
                        "}" % (config, exceptionCode))

        return handleOptional(templateBody, declType, handleDefaultNull("None"))

    if type.isUnion():
        declType = CGGeneric(union_native_type(type))
        if type.nullable():
            declType = CGWrapper(declType, pre="Option<", post=" >")

        templateBody = ("match FromJSValConvertible::from_jsval(cx, ${val}, ()) {\n"
                        "    Ok(value) => value,\n"
                        "    Err(()) => { %s },\n"
                        "}" % exceptionCode)

        return handleOptional(templateBody, declType, handleDefaultNull("None"))

    if type.isGeckoInterface():
        assert not isEnforceRange and not isClamp

        descriptor = descriptorProvider.getDescriptor(
            type.unroll().inner.identifier.name)

        if descriptor.interface.isCallback():
            name = descriptor.nativeType
            declType = CGWrapper(CGGeneric(name), pre="Rc<", post=">")
            template = "%s::new(${val}.get().to_object())" % name
            if type.nullable():
                declType = CGWrapper(declType, pre="Option<", post=">")
                template = wrapObjectTemplate("Some(%s)" % template, "None",
                                              isDefinitelyObject, type,
                                              failureCode)

            return handleOptional(template, declType, handleDefaultNull("None"))

        conversionFunction = "root_from_handlevalue"
        descriptorType = descriptor.returnType
        if isMember == "Variadic":
            conversionFunction = "native_from_handlevalue"
            descriptorType = descriptor.nativeType
        elif isArgument:
            descriptorType = descriptor.argumentType

        templateBody = ""
        if descriptor.interface.isConsequential():
            raise TypeError("Consequential interface %s being used as an "
                            "argument" % descriptor.interface.identifier.name)

        if failureCode is None:
            substitutions = {
                "sourceDescription": sourceDescription,
                "interface": descriptor.interface.identifier.name,
                "exceptionCode": exceptionCode,
            }
            unwrapFailureCode = string.Template(
                'throw_type_error(cx, "${sourceDescription} does not '
                'implement interface ${interface}.");\n'
                '${exceptionCode}').substitute(substitutions)
        else:
            unwrapFailureCode = failureCode

        templateBody = unwrapCastableObject(
            descriptor, "${val}", unwrapFailureCode, conversionFunction)

        declType = CGGeneric(descriptorType)
        if type.nullable():
            templateBody = "Some(%s)" % templateBody
            declType = CGWrapper(declType, pre="Option<", post=">")

        templateBody = wrapObjectTemplate(templateBody, "None",
                                          isDefinitelyObject, type, failureCode)

        return handleOptional(templateBody, declType, handleDefaultNull("None"))

    if type.isSpiderMonkeyInterface():
        raise TypeError("Can't handle SpiderMonkey interface arguments yet")

    if type.isDOMString():
        nullBehavior = getConversionConfigForType(type, isEnforceRange, isClamp, treatNullAs)

        conversionCode = (
            "match FromJSValConvertible::from_jsval(cx, ${val}, %s) {\n"
            "    Ok(strval) => strval,\n"
            "    Err(_) => { %s },\n"
            "}" % (nullBehavior, exceptionCode))

        if defaultValue is None:
            default = None
        elif isinstance(defaultValue, IDLNullValue):
            assert type.nullable()
            default = "None"
        else:
            assert defaultValue.type.tag() == IDLType.Tags.domstring
            default = 'DOMString::from("%s")' % defaultValue.value
            if type.nullable():
                default = "Some(%s)" % default

        declType = "DOMString"
        if type.nullable():
            declType = "Option<%s>" % declType

        return handleOptional(conversionCode, CGGeneric(declType), default)

    if type.isUSVString():
        assert not isEnforceRange and not isClamp

        conversionCode = (
            "match FromJSValConvertible::from_jsval(cx, ${val}, ()) {\n"
            "    Ok(strval) => strval,\n"
            "    Err(_) => { %s },\n"
            "}" % exceptionCode)

        if defaultValue is None:
            default = None
        elif isinstance(defaultValue, IDLNullValue):
            assert type.nullable()
            default = "None"
        else:
            assert defaultValue.type.tag() in (IDLType.Tags.domstring, IDLType.Tags.usvstring)
            default = 'USVString("%s".to_owned())' % defaultValue.value
            if type.nullable():
                default = "Some(%s)" % default

        declType = "USVString"
        if type.nullable():
            declType = "Option<%s>" % declType

        return handleOptional(conversionCode, CGGeneric(declType), default)

    if type.isByteString():
        assert not isEnforceRange and not isClamp

        conversionCode = (
            "match FromJSValConvertible::from_jsval(cx, ${val}, ()) {\n"
            "    Ok(strval) => strval,\n"
            "    Err(_) => { %s },\n"
            "}" % exceptionCode)

        if defaultValue is None:
            default = None
        elif isinstance(defaultValue, IDLNullValue):
            assert type.nullable()
            default = "None"
        else:
            assert defaultValue.type.tag() in (IDLType.Tags.domstring, IDLType.Tags.bytestring)
            default = 'ByteString::new(b"%s".to_vec())' % defaultValue.value
            if type.nullable():
                default = "Some(%s)" % default

        declType = "ByteString"
        if type.nullable():
            declType = "Option<%s>" % declType

        return handleOptional(conversionCode, CGGeneric(declType), default)

    if type.isEnum():
        assert not isEnforceRange and not isClamp

        if type.nullable():
            raise TypeError("We don't support nullable enumerated arguments "
                            "yet")
        enum = type.inner.identifier.name
        if invalidEnumValueFatal:
            handleInvalidEnumValueCode = onFailureInvalidEnumValue(failureCode, 'search').define()
        else:
            handleInvalidEnumValueCode = "return true;"

        template = (
            "match find_enum_string_index(cx, ${val}, %(values)s) {\n"
            "    Err(_) => { %(exceptionCode)s },\n"
            "    Ok((None, search)) => { %(handleInvalidEnumValueCode)s },\n"
            "    Ok((Some(index), _)) => {\n"
            "        //XXXjdm need some range checks up in here.\n"
            "        mem::transmute(index)\n"
            "    },\n"
            "}" % {"values": enum + "Values::strings",
                   "exceptionCode": exceptionCode,
                   "handleInvalidEnumValueCode": handleInvalidEnumValueCode})

        if defaultValue is not None:
            assert defaultValue.type.tag() == IDLType.Tags.domstring
            default = "%s::%s" % (enum, getEnumValueName(defaultValue.value))
        else:
            default = None

        return handleOptional(template, CGGeneric(enum), default)

    if type.isCallback():
        assert not isEnforceRange and not isClamp
        assert not type.treatNonCallableAsNull()
        assert not type.treatNonObjectAsNull() or type.nullable()
        assert not type.treatNonObjectAsNull() or not type.treatNonCallableAsNull()

        callback = type.unroll().callback
        declType = CGGeneric('%s::%s' % (getModuleFromObject(callback), callback.identifier.name))
        finalDeclType = CGTemplatedType("Rc", declType)

        conversion = CGCallbackTempRoot(declType.define())

        if type.nullable():
            declType = CGTemplatedType("Option", declType)
            finalDeclType = CGTemplatedType("Option", finalDeclType)
            conversion = CGWrapper(conversion, pre="Some(", post=")")

        if allowTreatNonObjectAsNull and type.treatNonObjectAsNull():
            if not isDefinitelyObject:
                haveObject = "${val}.get().is_object()"
                template = CGIfElseWrapper(haveObject,
                                           conversion,
                                           CGGeneric("None")).define()
            else:
                template = conversion
        else:
            template = CGIfElseWrapper("IsCallable(${val}.get().to_object())",
                                       conversion,
                                       onFailureNotCallable(failureCode)).define()
            template = wrapObjectTemplate(
                template,
                "None",
                isDefinitelyObject,
                type,
                failureCode)

        if defaultValue is not None:
            assert allowTreatNonObjectAsNull
            assert type.treatNonObjectAsNull()
            assert type.nullable()
            assert isinstance(defaultValue, IDLNullValue)
            default = "None"
        else:
            default = None

        return JSToNativeConversionInfo(template, default, finalDeclType, needsRooting=needsRooting)

    if type.isAny():
        assert not isEnforceRange and not isClamp

        declType = ""
        default = ""
        if isMember == "Dictionary":
            # TODO: Need to properly root dictionaries
            # https://github.com/servo/servo/issues/6381
            declType = CGGeneric("JSVal")

            if defaultValue is None:
                default = None
            elif isinstance(defaultValue, IDLNullValue):
                default = "NullValue()"
            elif isinstance(defaultValue, IDLUndefinedValue):
                default = "UndefinedValue()"
            else:
                raise TypeError("Can't handle non-null, non-undefined default value here")
        else:
            declType = CGGeneric("HandleValue")

            if defaultValue is None:
                default = None
            elif isinstance(defaultValue, IDLNullValue):
                default = "HandleValue::null()"
            elif isinstance(defaultValue, IDLUndefinedValue):
                default = "HandleValue::undefined()"
            else:
                raise TypeError("Can't handle non-null, non-undefined default value here")

        return handleOptional("${val}", declType, default)

    if type.isObject():
        assert not isEnforceRange and not isClamp

        # TODO: Need to root somehow
        # https://github.com/servo/servo/issues/6382
        declType = CGGeneric("*mut JSObject")
        templateBody = wrapObjectTemplate("${val}.get().to_object()",
                                          "ptr::null_mut()",
                                          isDefinitelyObject, type, failureCode)

        return handleOptional(templateBody, declType,
                              handleDefaultNull("ptr::null_mut()"))

    if type.isDictionary():
        if failureCode is not None:
            raise TypeError("Can't handle dictionaries when failureCode is not None")
        # There are no nullable dictionaries
        assert not type.nullable()

        typeName = "%s::%s" % (CGDictionary.makeModuleName(type.inner),
                               CGDictionary.makeDictionaryName(type.inner))
        declType = CGGeneric(typeName)
        template = ("match %s::new(cx, ${val}) {\n"
                    "    Ok(dictionary) => dictionary,\n"
                    "    Err(_) => { %s },\n"
                    "}" % (typeName, exceptionCode))

        return handleOptional(template, declType, handleDefaultNull("%s::empty(cx)" % typeName))

    if type.isVoid():
        # This one only happens for return values, and its easy: Just
        # ignore the jsval.
        return JSToNativeConversionInfo("", None, None, needsRooting=False)

    if not type.isPrimitive():
        raise TypeError("Need conversion for argument type '%s'" % str(type))

    conversionBehavior = getConversionConfigForType(type, isEnforceRange, isClamp, treatNullAs)

    if failureCode is None:
        failureCode = 'return false'

    declType = CGGeneric(builtinNames[type.tag()])
    if type.nullable():
        declType = CGWrapper(declType, pre="Option<", post=">")

    template = (
        "match FromJSValConvertible::from_jsval(cx, ${val}, %s) {\n"
        "    Ok(v) => v,\n"
        "    Err(_) => { %s }\n"
        "}" % (conversionBehavior, exceptionCode))

    if defaultValue is not None:
        if isinstance(defaultValue, IDLNullValue):
            assert type.nullable()
            defaultStr = "None"
        else:
            tag = defaultValue.type.tag()
            if tag in [IDLType.Tags.float, IDLType.Tags.double]:
                defaultStr = "Finite::wrap(%s)" % defaultValue.value
            elif tag in numericTags:
                defaultStr = str(defaultValue.value)
            else:
                assert tag == IDLType.Tags.bool
                defaultStr = toStringBool(defaultValue.value)

            if type.nullable():
                defaultStr = "Some(%s)" % defaultStr
    else:
        defaultStr = None

    return handleOptional(template, declType, defaultStr)


def instantiateJSToNativeConversionTemplate(templateBody, replacements,
                                            declType, declName):
    """
    Take the templateBody and declType as returned by
    getJSToNativeConversionInfo, a set of replacements as required by the
    strings in such a templateBody, and a declName, and generate code to
    convert into a stack Rust binding with that name.
    """
    result = CGList([], "\n")

    conversion = CGGeneric(string.Template(templateBody).substitute(replacements))

    if declType is not None:
        newDecl = [
            CGGeneric("let "),
            CGGeneric(declName),
            CGGeneric(": "),
            declType,
            CGGeneric(" = "),
            conversion,
            CGGeneric(";"),
        ]
        result.append(CGList(newDecl))
    else:
        result.append(conversion)

    # Add an empty CGGeneric to get an extra newline after the argument
    # conversion.
    result.append(CGGeneric(""))

    return result


def convertConstIDLValueToJSVal(value):
    if isinstance(value, IDLNullValue):
        return "NullVal"
    tag = value.type.tag()
    if tag in [IDLType.Tags.int8, IDLType.Tags.uint8, IDLType.Tags.int16,
               IDLType.Tags.uint16, IDLType.Tags.int32]:
        return "IntVal(%s)" % (value.value)
    if tag == IDLType.Tags.uint32:
        return "UintVal(%s)" % (value.value)
    if tag in [IDLType.Tags.int64, IDLType.Tags.uint64]:
        return "DoubleVal(%s)" % (value.value)
    if tag == IDLType.Tags.bool:
        return "BoolVal(true)" if value.value else "BoolVal(false)"
    if tag in [IDLType.Tags.unrestricted_float, IDLType.Tags.float,
               IDLType.Tags.unrestricted_double, IDLType.Tags.double]:
        return "DoubleVal(%s)" % (value.value)
    raise TypeError("Const value of unhandled type: " + value.type)


class CGArgumentConverter(CGThing):
    """
    A class that takes an IDL argument object, its index in the
    argument list, and the argv and argc strings and generates code to
    unwrap the argument to the right native type.
    """
    def __init__(self, argument, index, args, argc, descriptorProvider,
                 invalidEnumValueFatal=True):
        CGThing.__init__(self)
        assert not argument.defaultValue or argument.optional

        replacer = {
            "index": index,
            "argc": argc,
            "args": args
        }

        replacementVariables = {
            "val": string.Template("${args}.get(${index})").substitute(replacer),
        }

        info = getJSToNativeConversionInfo(
            argument.type,
            descriptorProvider,
            invalidEnumValueFatal=invalidEnumValueFatal,
            defaultValue=argument.defaultValue,
            treatNullAs=argument.treatNullAs,
            isEnforceRange=argument.enforceRange,
            isClamp=argument.clamp,
            isMember="Variadic" if argument.variadic else False,
            allowTreatNonObjectAsNull=argument.allowTreatNonCallableAsNull())
        template = info.template
        default = info.default
        declType = info.declType

        if not argument.variadic:
            if argument.optional:
                condition = "{args}.get({index}).is_undefined()".format(**replacer)
                if argument.defaultValue:
                    assert default
                    template = CGIfElseWrapper(condition,
                                               CGGeneric(default),
                                               CGGeneric(template)).define()
                else:
                    assert not default
                    declType = CGWrapper(declType, pre="Option<", post=">")
                    template = CGIfElseWrapper(condition,
                                               CGGeneric("None"),
                                               CGGeneric("Some(%s)" % template)).define()
            else:
                assert not default

            self.converter = instantiateJSToNativeConversionTemplate(
                template, replacementVariables, declType, "arg%d" % index)
        else:
            assert argument.optional
            variadicConversion = {
                "val": string.Template("${args}.get(variadicArg)").substitute(replacer),
            }
            innerConverter = [instantiateJSToNativeConversionTemplate(
                template, variadicConversion, declType, "slot")]

            arg = "arg%d" % index
            if argument.type.isGeckoInterface():
                init = "rooted_vec!(let mut %s)" % arg
                innerConverter.append(CGGeneric("%s.push(JS::from_ref(&*slot));" % arg))
            else:
                init = "let mut %s = vec![]" % arg
                innerConverter.append(CGGeneric("%s.push(slot);" % arg))
            inner = CGIndenter(CGList(innerConverter, "\n"), 8).define()

            self.converter = CGGeneric("""\
%(init)s;
if %(argc)s > %(index)s {
    %(arg)s.reserve(%(argc)s as usize - %(index)s);
    for variadicArg in %(index)s..%(argc)s {
%(inner)s
    }
}""" % {'arg': arg, 'argc': argc, 'index': index, 'inner': inner, 'init': init})

    def define(self):
        return self.converter.define()


def wrapForType(jsvalRef, result='result', successCode='return true;', pre=''):
    """
    Reflect a Rust value into JS.

      * 'jsvalRef': a MutableHandleValue in which to store the result
                    of the conversion;
      * 'result': the name of the variable in which the Rust value is stored;
      * 'successCode': the code to run once we have done the conversion.
      * 'pre': code to run before the conversion if rooting is necessary
    """
    wrap = "%s\n(%s).to_jsval(cx, %s);" % (pre, result, jsvalRef)
    if successCode:
        wrap += "\n%s" % successCode
    return wrap


def typeNeedsCx(type, retVal=False):
    if type is None:
        return False
    if type.nullable():
        type = type.inner
    if type.isSequence() or type.isArray():
        type = type.inner
    if type.isUnion():
        return any(typeNeedsCx(t) for t in type.unroll().flatMemberTypes)
    if retVal and type.isSpiderMonkeyInterface():
        return True
    return type.isAny() or type.isObject()


# Returns a conversion behavior suitable for a type
def getConversionConfigForType(type, isEnforceRange, isClamp, treatNullAs):
    if type.isSequence():
        return getConversionConfigForType(type.unroll(), isEnforceRange, isClamp, treatNullAs)
    if type.isDOMString():
        assert not isEnforceRange and not isClamp

        treatAs = {
            "Default": "StringificationBehavior::Default",
            "EmptyString": "StringificationBehavior::Empty",
        }
        if treatNullAs not in treatAs:
            raise TypeError("We don't support [TreatNullAs=%s]" % treatNullAs)
        if type.nullable():
            # Note: the actual behavior passed here doesn't matter for nullable
            # strings.
            return "StringificationBehavior::Default"
        else:
            return treatAs[treatNullAs]
    if type.isPrimitive() and type.isInteger():
        if isEnforceRange:
            return "ConversionBehavior::EnforceRange"
        elif isClamp:
            return "ConversionBehavior::Clamp"
        else:
            return "ConversionBehavior::Default"
    assert not isEnforceRange and not isClamp
    return "()"


# Returns a CGThing containing the type of the return value.
def getRetvalDeclarationForType(returnType, descriptorProvider):
    if returnType is None or returnType.isVoid():
        # Nothing to declare
        return CGGeneric("()")
    if returnType.isPrimitive() and returnType.tag() in builtinNames:
        result = CGGeneric(builtinNames[returnType.tag()])
        if returnType.nullable():
            result = CGWrapper(result, pre="Option<", post=">")
        return result
    if returnType.isDOMString():
        result = CGGeneric("DOMString")
        if returnType.nullable():
            result = CGWrapper(result, pre="Option<", post=">")
        return result
    if returnType.isUSVString():
        result = CGGeneric("USVString")
        if returnType.nullable():
            result = CGWrapper(result, pre="Option<", post=">")
        return result
    if returnType.isByteString():
        result = CGGeneric("ByteString")
        if returnType.nullable():
            result = CGWrapper(result, pre="Option<", post=">")
        return result
    if returnType.isEnum():
        result = CGGeneric(returnType.unroll().inner.identifier.name)
        if returnType.nullable():
            result = CGWrapper(result, pre="Option<", post=">")
        return result
    if returnType.isGeckoInterface():
        descriptor = descriptorProvider.getDescriptor(
            returnType.unroll().inner.identifier.name)
        result = CGGeneric(descriptor.returnType)
        if returnType.nullable():
            result = CGWrapper(result, pre="Option<", post=">")
        return result
    if returnType.isCallback():
        callback = returnType.unroll().callback
        result = CGGeneric('Rc<%s::%s>' % (getModuleFromObject(callback), callback.identifier.name))
        if returnType.nullable():
            result = CGWrapper(result, pre="Option<", post=">")
        return result
    if returnType.isUnion():
        result = CGGeneric(union_native_type(returnType))
        if returnType.nullable():
            result = CGWrapper(result, pre="Option<", post=">")
        return result
    # TODO: Return the value through a MutableHandleValue outparam
    # https://github.com/servo/servo/issues/6307
    if returnType.isAny():
        return CGGeneric("JSVal")
    if returnType.isObject() or returnType.isSpiderMonkeyInterface():
        return CGGeneric("*mut JSObject")
    if returnType.isSequence():
        result = getRetvalDeclarationForType(innerSequenceType(returnType), descriptorProvider)
        result = CGWrapper(result, pre="Vec<", post=">")
        if returnType.nullable():
            result = CGWrapper(result, pre="Option<", post=">")
        return result
    if returnType.isDictionary():
        nullable = returnType.nullable()
        dictName = returnType.inner.name if nullable else returnType.name
        result = CGGeneric(dictName)
        if typeNeedsRooting(returnType, descriptorProvider):
            raise TypeError("We don't support rootable dictionaries return values")
        if nullable:
            result = CGWrapper(result, pre="Option<", post=">")
        return result

    raise TypeError("Don't know how to declare return value for %s" %
                    returnType)


def MemberCondition(pref, func):
    """
    A string representing the condition for a member to actually be exposed.
    Any of the arguments can be None. If not None, they should have the
    following types:

    pref: The name of the preference.
    func: The name of the function.
    """
    assert pref is None or isinstance(pref, str)
    assert func is None or isinstance(func, str)
    assert func is None or pref is None
    if pref:
        return 'Condition::Pref("%s")' % pref
    if func:
        return 'Condition::Func(%s)' % func
    return "Condition::Satisfied"


class PropertyDefiner:
    """
    A common superclass for defining things on prototype objects.

    Subclasses should implement generateArray to generate the actual arrays of
    things we're defining. They should also set self.regular to the list of
    things exposed to web pages.
    """
    def __init__(self, descriptor, name):
        self.descriptor = descriptor
        self.name = name

    def variableName(self):
        return "s" + self.name

    def length(self):
        return len(self.regular)

    def __str__(self):
        # We only need to generate id arrays for things that will end
        # up used via ResolveProperty or EnumerateProperties.
        return self.generateArray(self.regular, self.variableName())

    @staticmethod
    def getStringAttr(member, name):
        attr = member.getExtendedAttribute(name)
        if attr is None:
            return None
        # It's a list of strings
        assert len(attr) == 1
        assert attr[0] is not None
        return attr[0]

    @staticmethod
    def getControllingCondition(interfaceMember, descriptor):
        return MemberCondition(
            PropertyDefiner.getStringAttr(interfaceMember,
                                          "Pref"),
            PropertyDefiner.getStringAttr(interfaceMember,
                                          "Func"))

    def generateGuardedArray(self, array, name, specTemplate, specTerminator,
                             specType, getCondition, getDataTuple):
        """
        This method generates our various arrays.

        array is an array of interface members as passed to generateArray

        name is the name as passed to generateArray

        specTemplate is a template for each entry of the spec array

        specTerminator is a terminator for the spec array (inserted at the end
          of the array), or None

        specType is the actual typename of our spec

        getDataTuple is a callback function that takes an array entry and
          returns a tuple suitable for substitution into specTemplate.
        """

        # We generate an all-encompassing list of lists of specs, with each sublist
        # representing a group of members that share a common pref name. That will
        # make sure the order of the properties as exposed on the interface and
        # interface prototype objects does not change when pref control is added to
        # members while still allowing us to define all the members in the smallest
        # number of JSAPI calls.
        assert len(array) != 0
        specs = []
        prefableSpecs = []
        prefableTemplate = '    Guard::new(%s, %s[%d])'

        for cond, members in groupby(array, lambda m: getCondition(m, self.descriptor)):
            currentSpecs = [specTemplate % getDataTuple(m) for m in members]
            if specTerminator:
                currentSpecs.append(specTerminator)
            specs.append("&[\n" + ",\n".join(currentSpecs) + "]\n")
            prefableSpecs.append(
                prefableTemplate % (cond, name + "_specs", len(specs) - 1))

        specsArray = ("const %s_specs: &'static [&'static[%s]] = &[\n" +
                      ",\n".join(specs) + "\n" +
                      "];\n") % (name, specType)

        prefArray = ("const %s: &'static [Guard<&'static [%s]>] = &[\n" +
                     ",\n".join(prefableSpecs) + "\n" +
                     "];\n") % (name, specType)
        return specsArray + prefArray


# The length of a method is the minimum of the lengths of the
# argument lists of all its overloads.
def methodLength(method):
    signatures = method.signatures()
    return min(
        len([arg for arg in arguments if not arg.optional and not arg.variadic])
        for (_, arguments) in signatures)


class MethodDefiner(PropertyDefiner):
    """
    A class for defining methods on a prototype object.
    """
    def __init__(self, descriptor, name, static, unforgeable):
        assert not (static and unforgeable)
        PropertyDefiner.__init__(self, descriptor, name)

        # FIXME https://bugzilla.mozilla.org/show_bug.cgi?id=772822
        #       We should be able to check for special operations without an
        #       identifier. For now we check if the name starts with __

        # Ignore non-static methods for callback interfaces
        if not descriptor.interface.isCallback() or static:
            methods = [m for m in descriptor.interface.members if
                       m.isMethod() and m.isStatic() == static and
                       not m.isIdentifierLess() and
                       MemberIsUnforgeable(m, descriptor) == unforgeable]
        else:
            methods = []
        self.regular = [{"name": m.identifier.name,
                         "methodInfo": not m.isStatic(),
                         "length": methodLength(m),
                         "condition": PropertyDefiner.getControllingCondition(m, descriptor)}
                        for m in methods]

        # FIXME Check for an existing iterator on the interface first.
        if any(m.isGetter() and m.isIndexed() for m in methods):
            self.regular.append({"name": '@@iterator',
                                 "methodInfo": False,
                                 "selfHostedName": "ArrayValues",
                                 "length": 0,
                                 "condition": "Condition::Satisfied"})

        isUnforgeableInterface = bool(descriptor.interface.getExtendedAttribute("Unforgeable"))
        if not static and unforgeable == isUnforgeableInterface:
            stringifier = descriptor.operations['Stringifier']
            if stringifier:
                self.regular.append({
                    "name": "toString",
                    "nativeName": stringifier.identifier.name,
                    "length": 0,
                    "condition": PropertyDefiner.getControllingCondition(stringifier, descriptor)
                })
        self.unforgeable = unforgeable

    def generateArray(self, array, name):
        if len(array) == 0:
            return ""

        def condition(m, d):
            return m["condition"]

        flags = "JSPROP_ENUMERATE"
        if self.unforgeable:
            flags += " | JSPROP_PERMANENT | JSPROP_READONLY"

        def specData(m):
            # TODO: Use something like JS_FNSPEC
            # https://github.com/servo/servo/issues/6391
            if "selfHostedName" in m:
                selfHostedName = '%s as *const u8 as *const libc::c_char' % str_to_const_array(m["selfHostedName"])
                assert not m.get("methodInfo", True)
                accessor = "None"
                jitinfo = "0 as *const JSJitInfo"
            else:
                selfHostedName = "0 as *const libc::c_char"
                if m.get("methodInfo", True):
                    identifier = m.get("nativeName", m["name"])
                    # Go through an intermediate type here, because it's not
                    # easy to tell whether the methodinfo is a JSJitInfo or
                    # a JSTypedMethodJitInfo here.  The compiler knows, though,
                    # so let it do the work.
                    jitinfo = "&%s_methodinfo as *const _ as *const JSJitInfo" % identifier
                    accessor = "Some(generic_method)"
                else:
                    jitinfo = "0 as *const JSJitInfo"
                    accessor = 'Some(%s)' % m.get("nativeName", m["name"])
            if m["name"].startswith("@@"):
                return ('(SymbolCode::%s as i32 + 1)'
                        % m["name"][2:], accessor, jitinfo, m["length"], flags, selfHostedName)
            return (str_to_const_array(m["name"]), accessor, jitinfo, m["length"], flags, selfHostedName)

        return self.generateGuardedArray(
            array, name,
            '    JSFunctionSpec {\n'
            '        name: %s as *const u8 as *const libc::c_char,\n'
            '        call: JSNativeWrapper { op: %s, info: %s },\n'
            '        nargs: %s,\n'
            '        flags: (%s) as u16,\n'
            '        selfHostedName: %s\n'
            '    }',
            '    JSFunctionSpec {\n'
            '        name: 0 as *const libc::c_char,\n'
            '        call: JSNativeWrapper { op: None, info: 0 as *const JSJitInfo },\n'
            '        nargs: 0,\n'
            '        flags: 0,\n'
            '        selfHostedName: 0 as *const libc::c_char\n'
            '    }',
            'JSFunctionSpec',
            condition, specData)


class AttrDefiner(PropertyDefiner):
    def __init__(self, descriptor, name, static, unforgeable):
        assert not (static and unforgeable)
        PropertyDefiner.__init__(self, descriptor, name)
        self.name = name
        self.descriptor = descriptor
        self.regular = [
            m
            for m in descriptor.interface.members if
            m.isAttr() and m.isStatic() == static and
            MemberIsUnforgeable(m, descriptor) == unforgeable
        ]
        self.static = static
        self.unforgeable = unforgeable

    def generateArray(self, array, name):
        if len(array) == 0:
            return ""

        flags = "JSPROP_ENUMERATE | JSPROP_SHARED"
        if self.unforgeable:
            flags += " | JSPROP_PERMANENT"

        def getter(attr):
            if self.static:
                accessor = 'get_' + self.descriptor.internalNameFor(attr.identifier.name)
                jitinfo = "0 as *const JSJitInfo"
            else:
                if attr.hasLenientThis():
                    accessor = "generic_lenient_getter"
                else:
                    accessor = "generic_getter"
                jitinfo = "&%s_getterinfo" % self.descriptor.internalNameFor(attr.identifier.name)

            return ("JSNativeWrapper { op: Some(%(native)s), info: %(info)s }"
                    % {"info": jitinfo,
                       "native": accessor})

        def setter(attr):
            if attr.readonly and not attr.getExtendedAttribute("PutForwards"):
                return "JSNativeWrapper { op: None, info: 0 as *const JSJitInfo }"

            if self.static:
                accessor = 'set_' + self.descriptor.internalNameFor(attr.identifier.name)
                jitinfo = "0 as *const JSJitInfo"
            else:
                if attr.hasLenientThis():
                    accessor = "generic_lenient_setter"
                else:
                    accessor = "generic_setter"
                jitinfo = "&%s_setterinfo" % self.descriptor.internalNameFor(attr.identifier.name)

            return ("JSNativeWrapper { op: Some(%(native)s), info: %(info)s }"
                    % {"info": jitinfo,
                       "native": accessor})

        def specData(attr):
            return (str_to_const_array(attr.identifier.name), flags, getter(attr),
                    setter(attr))

        return self.generateGuardedArray(
            array, name,
            '    JSPropertySpec {\n'
            '        name: %s as *const u8 as *const libc::c_char,\n'
            '        flags: (%s) as u8,\n'
            '        getter: %s,\n'
            '        setter: %s\n'
            '    }',
            '    JSPropertySpec {\n'
            '        name: 0 as *const libc::c_char,\n'
            '        flags: 0,\n'
            '        getter: JSNativeWrapper { op: None, info: 0 as *const JSJitInfo },\n'
            '        setter: JSNativeWrapper { op: None, info: 0 as *const JSJitInfo }\n'
            '    }',
            'JSPropertySpec',
            PropertyDefiner.getControllingCondition, specData)


class ConstDefiner(PropertyDefiner):
    """
    A class for definining constants on the interface object
    """
    def __init__(self, descriptor, name):
        PropertyDefiner.__init__(self, descriptor, name)
        self.name = name
        self.regular = [m for m in descriptor.interface.members if m.isConst()]

    def generateArray(self, array, name):
        if len(array) == 0:
            return ""

        def specData(const):
            return (str_to_const_array(const.identifier.name),
                    convertConstIDLValueToJSVal(const.value))

        return self.generateGuardedArray(
            array, name,
            '    ConstantSpec { name: %s, value: %s }',
            None,
            'ConstantSpec',
            PropertyDefiner.getControllingCondition, specData)

# We'll want to insert the indent at the beginnings of lines, but we
# don't want to indent empty lines.  So only indent lines that have a
# non-newline character on them.
lineStartDetector = re.compile("^(?=[^\n])", re.MULTILINE)


class CGIndenter(CGThing):
    """
    A class that takes another CGThing and generates code that indents that
    CGThing by some number of spaces.  The default indent is two spaces.
    """
    def __init__(self, child, indentLevel=4):
        CGThing.__init__(self)
        self.child = child
        self.indent = " " * indentLevel

    def define(self):
        defn = self.child.define()
        if defn != "":
            return re.sub(lineStartDetector, self.indent, defn)
        else:
            return defn


class CGWrapper(CGThing):
    """
    Generic CGThing that wraps other CGThings with pre and post text.
    """
    def __init__(self, child, pre="", post="", reindent=False):
        CGThing.__init__(self)
        self.child = child
        self.pre = pre
        self.post = post
        self.reindent = reindent

    def define(self):
        defn = self.child.define()
        if self.reindent:
            # We don't use lineStartDetector because we don't want to
            # insert whitespace at the beginning of our _first_ line.
            defn = stripTrailingWhitespace(
                defn.replace("\n", "\n" + (" " * len(self.pre))))
        return self.pre + defn + self.post


class CGImports(CGWrapper):
    """
    Generates the appropriate import/use statements.
    """
    def __init__(self, child, descriptors, callbacks, imports, config, ignored_warnings=None):
        """
        Adds a set of imports.
        """
        if ignored_warnings is None:
            ignored_warnings = [
                'non_camel_case_types',
                'non_upper_case_globals',
                'unused_imports',
                'unused_variables',
                'unused_assignments',
            ]

        def componentTypes(type):
            if type.nullable():
                type = type.unroll()
            if type.isUnion():
                return type.flatMemberTypes
            return [type]

        def isImportable(type):
            if not type.isType():
                assert type.isInterface()
                return not type.isCallback()
            return type.isNonCallbackInterface() and not type.builtin

        def relatedTypesForSignatures(method):
            types = []
            for (returnType, arguments) in method.signatures():
                types += componentTypes(returnType)
                for arg in arguments:
                    types += componentTypes(arg.type)
            return types

        def getIdentifier(t):
            if t.isType():
                return t.inner.identifier
            assert t.isInterface()
            return t.identifier

        types = []
        for d in descriptors:
            types += [d.interface]

            members = d.interface.members + d.interface.namedConstructors
            constructor = d.interface.ctor()
            if constructor:
                members += [constructor]

            if d.proxy:
                members += [o for o in d.operations.values() if o]

            for m in members:
                if m.isMethod():
                    types += relatedTypesForSignatures(m)
                elif m.isAttr():
                    types += componentTypes(m.type)

        for c in callbacks:
            types += relatedTypesForSignatures(c)

        descriptorProvider = config.getDescriptorProvider()
        for t in types:
            if isImportable(t):
                descriptor = descriptorProvider.getDescriptor(getIdentifier(t).name)
                imports += ['%s' % descriptor.path]

        statements = []
        if len(ignored_warnings) > 0:
            statements.append('#![allow(%s)]' % ','.join(ignored_warnings))
        statements.extend('use %s;' % i for i in sorted(set(imports)))

        CGWrapper.__init__(self, child,
                           pre='\n'.join(statements) + '\n\n')


class CGIfWrapper(CGWrapper):
    def __init__(self, condition, child):
        pre = CGWrapper(CGGeneric(condition), pre="if ", post=" {\n",
                        reindent=True)
        CGWrapper.__init__(self, CGIndenter(child), pre=pre.define(),
                           post="\n}")


class CGTemplatedType(CGWrapper):
    def __init__(self, templateName, child):
        CGWrapper.__init__(self, child, pre=templateName + "<", post=">")


class CGNamespace(CGWrapper):
    def __init__(self, namespace, child, public=False):
        pre = "%smod %s {\n" % ("pub " if public else "", namespace)
        post = "} // mod %s" % namespace
        CGWrapper.__init__(self, child, pre=pre, post=post)

    @staticmethod
    def build(namespaces, child, public=False):
        """
        Static helper method to build multiple wrapped namespaces.
        """
        if not namespaces:
            return child
        inner = CGNamespace.build(namespaces[1:], child, public=public)
        return CGNamespace(namespaces[0], inner, public=public)


def DOMClassTypeId(desc):
    protochain = desc.prototypeChain
    inner = ""
    if desc.hasDescendants():
        if desc.interface.getExtendedAttribute("Abstract"):
            return "::dom::bindings::codegen::InheritTypes::TopTypeId::Abstract"
        name = desc.interface.identifier.name
        inner = "(::dom::bindings::codegen::InheritTypes::%sTypeId::%s)" % (name, name)
    elif len(protochain) == 1:
        return "::dom::bindings::codegen::InheritTypes::TopTypeId::Alone"
    reversed_protochain = list(reversed(protochain))
    for (child, parent) in zip(reversed_protochain, reversed_protochain[1:]):
        inner = "(::dom::bindings::codegen::InheritTypes::%sTypeId::%s%s)" % (parent, child, inner)
    return "::dom::bindings::codegen::InheritTypes::TopTypeId::%s%s" % (protochain[0], inner)


def DOMClass(descriptor):
    protoList = ['PrototypeList::ID::' + proto for proto in descriptor.prototypeChain]
    # Pad out the list to the right length with ID::Last so we
    # guarantee that all the lists are the same length.  ID::Last
    # is never the ID of any prototype, so it's safe to use as
    # padding.
    protoList.extend(['PrototypeList::ID::Last'] * (descriptor.config.maxProtoChainLength - len(protoList)))
    prototypeChainString = ', '.join(protoList)
    heapSizeOf = 'heap_size_of_raw_self_and_children::<%s>' % descriptor.interface.identifier.name
    if descriptor.isGlobal():
        globals_ = camel_to_upper_snake(descriptor.name)
    else:
        globals_ = 'EMPTY'
    return """\
DOMClass {
    interface_chain: [ %s ],
    type_id: %s,
    heap_size_of: %s as unsafe fn(_) -> _,
    global: InterfaceObjectMap::%s,
}""" % (prototypeChainString, DOMClassTypeId(descriptor), heapSizeOf, globals_)


class CGDOMJSClass(CGThing):
    """
    Generate a DOMJSClass for a given descriptor
    """
    def __init__(self, descriptor):
        CGThing.__init__(self)
        self.descriptor = descriptor

    def define(self):
        args = {
            "domClass": DOMClass(self.descriptor),
            "enumerateHook": "None",
            "finalizeHook": FINALIZE_HOOK_NAME,
            "flags": "0",
            "name": str_to_const_array(self.descriptor.interface.identifier.name),
            "resolveHook": "None",
            "slots": "1",
            "traceHook": TRACE_HOOK_NAME,
        }
        if self.descriptor.isGlobal():
            assert not self.descriptor.weakReferenceable
            args["enumerateHook"] = "Some(enumerate_global)"
            args["flags"] = "JSCLASS_IS_GLOBAL | JSCLASS_DOM_GLOBAL"
            args["slots"] = "JSCLASS_GLOBAL_SLOT_COUNT + 1"
            args["resolveHook"] = "Some(resolve_global)"
            args["traceHook"] = "js::jsapi::JS_GlobalObjectTraceHook"
        elif self.descriptor.weakReferenceable:
            args["slots"] = "2"
        return """\
static CLASS_OPS: js::jsapi::ClassOps = js::jsapi::ClassOps {
    addProperty: None,
    delProperty: None,
    getProperty: None,
    setProperty: None,
    enumerate: %(enumerateHook)s,
    resolve: %(resolveHook)s,
    mayResolve: None,
    finalize: Some(%(finalizeHook)s),
    call: None,
    hasInstance: None,
    construct: None,
    trace: Some(%(traceHook)s),
};

static Class: DOMJSClass = DOMJSClass {
    base: js::jsapi::Class {
        name: %(name)s as *const u8 as *const libc::c_char,
        flags: JSCLASS_IS_DOMJSCLASS | %(flags)s |
               (((%(slots)s) & JSCLASS_RESERVED_SLOTS_MASK) << JSCLASS_RESERVED_SLOTS_SHIFT)
               /* JSCLASS_HAS_RESERVED_SLOTS(%(slots)s) */,
        cOps: &CLASS_OPS,
        spec: ptr::null(),
        ext: ptr::null(),
        oOps: ptr::null(),
    },
    dom_class: %(domClass)s
};""" % args


def str_to_const_array(s):
    return "b\"%s\\0\"" % s


class CGPrototypeJSClass(CGThing):
    def __init__(self, descriptor):
        CGThing.__init__(self)
        self.descriptor = descriptor

    def define(self):
        name = str_to_const_array(self.descriptor.interface.identifier.name + "Prototype")
        slotCount = 0
        if self.descriptor.hasUnforgeableMembers:
            slotCount += 1
        return """\
static PrototypeClass: JSClass = JSClass {
    name: %(name)s as *const u8 as *const libc::c_char,
    flags:
        // JSCLASS_HAS_RESERVED_SLOTS(%(slotCount)s)
        (%(slotCount)s & JSCLASS_RESERVED_SLOTS_MASK) << JSCLASS_RESERVED_SLOTS_SHIFT,
    cOps: 0 as *const _,
    reserved: [0 as *mut os::raw::c_void; 3]
};
""" % {'name': name, 'slotCount': slotCount}


class CGInterfaceObjectJSClass(CGThing):
    def __init__(self, descriptor):
        assert descriptor.interface.hasInterfaceObject() and not descriptor.interface.isCallback()
        CGThing.__init__(self)
        self.descriptor = descriptor

    def define(self):
        if self.descriptor.interface.ctor():
            constructorBehavior = "InterfaceConstructorBehavior::call(%s)" % CONSTRUCT_HOOK_NAME
        else:
            constructorBehavior = "InterfaceConstructorBehavior::throw()"
        name = self.descriptor.interface.identifier.name
        args = {
            "constructorBehavior": constructorBehavior,
            "id": name,
            "representation": 'b"function %s() {\\n    [native code]\\n}"' % name,
            "depth": self.descriptor.prototypeDepth
        }
        return """\
static INTERFACE_OBJECT_OPS: js::jsapi::ClassOps =
    NonCallbackInterfaceObjectClass::ops(%(constructorBehavior)s);

static InterfaceObjectClass: NonCallbackInterfaceObjectClass =
    NonCallbackInterfaceObjectClass::new(
        &INTERFACE_OBJECT_OPS,
        %(representation)s,
        PrototypeList::ID::%(id)s,
        %(depth)s);
""" % args


class CGList(CGThing):
    """
    Generate code for a list of GCThings.  Just concatenates them together, with
    an optional joiner string.  "\n" is a common joiner.
    """
    def __init__(self, children, joiner=""):
        CGThing.__init__(self)
        # Make a copy of the kids into a list, because if someone passes in a
        # generator we won't be able to both declare and define ourselves, or
        # define ourselves more than once!
        self.children = list(children)
        self.joiner = joiner

    def append(self, child):
        self.children.append(child)

    def prepend(self, child):
        self.children.insert(0, child)

    def join(self, iterable):
        return self.joiner.join(s for s in iterable if len(s) > 0)

    def define(self):
        return self.join(child.define() for child in self.children if child is not None)

    def __len__(self):
        return len(self.children)


class CGIfElseWrapper(CGList):
    def __init__(self, condition, ifTrue, ifFalse):
        kids = [CGIfWrapper(condition, ifTrue),
                CGWrapper(CGIndenter(ifFalse), pre=" else {\n", post="\n}")]
        CGList.__init__(self, kids)


class CGGeneric(CGThing):
    """
    A class that spits out a fixed string into the codegen.  Can spit out a
    separate string for the declaration too.
    """
    def __init__(self, text):
        self.text = text

    def define(self):
        return self.text


class CGCallbackTempRoot(CGGeneric):
    def __init__(self, name):
        CGGeneric.__init__(self, "%s::new(${val}.get().to_object())" % name)


def getAllTypes(descriptors, dictionaries, callbacks):
    """
    Generate all the types we're dealing with.  For each type, a tuple
    containing type, descriptor, dictionary is yielded.  The
    descriptor and dictionary can be None if the type does not come
    from a descriptor or dictionary; they will never both be non-None.
    """
    for d in descriptors:
        for t in getTypesFromDescriptor(d):
            yield (t, d, None)
    for dictionary in dictionaries:
        for t in getTypesFromDictionary(dictionary):
            yield (t, None, dictionary)
    for callback in callbacks:
        for t in getTypesFromCallback(callback):
            yield (t, None, None)


def UnionTypes(descriptors, dictionaries, callbacks, config):
    """
    Returns a CGList containing CGUnionStructs for every union.
    """

    imports = [
        'dom::bindings::codegen::PrototypeList',
        'dom::bindings::conversions::FromJSValConvertible',
        'dom::bindings::conversions::ToJSValConvertible',
        'dom::bindings::conversions::ConversionBehavior',
        'dom::bindings::conversions::StringificationBehavior',
        'dom::bindings::conversions::root_from_handlevalue',
        'dom::bindings::error::throw_not_in_union',
        'dom::bindings::js::Root',
        'dom::bindings::str::{ByteString, DOMString, USVString}',
        'dom::types::*',
        'js::jsapi::JSContext',
        'js::jsapi::{HandleValue, MutableHandleValue}',
        'js::jsval::JSVal',
    ]

    # Now find all the things we'll need as arguments and return values because
    # we need to wrap or unwrap them.
    unionStructs = dict()
    for (t, descriptor, dictionary) in getAllTypes(descriptors, dictionaries, callbacks):
        assert not descriptor or not dictionary
        t = t.unroll()
        if not t.isUnion():
            continue
        name = str(t)
        if name not in unionStructs:
            provider = descriptor or config.getDescriptorProvider()
            unionStructs[name] = CGList([
                CGUnionStruct(t, provider),
                CGUnionConversionStruct(t, provider)
            ])

    # Sort unionStructs by key, retrieve value
    unionStructs = (i[1] for i in sorted(unionStructs.items(), key=operator.itemgetter(0)))

    return CGImports(CGList(unionStructs, "\n\n"), [], [], imports, config, ignored_warnings=[])


class Argument():
    """
    A class for outputting the type and name of an argument
    """
    def __init__(self, argType, name, default=None, mutable=False):
        self.argType = argType
        self.name = name
        self.default = default
        self.mutable = mutable

    def declare(self):
        string = ('mut ' if self.mutable else '') + self.name + ((': ' + self.argType) if self.argType else '')
        # XXXjdm Support default arguments somehow :/
        # if self.default is not None:
        #     string += " = " + self.default
        return string

    def define(self):
        return self.argType + ' ' + self.name


class CGAbstractMethod(CGThing):
    """
    An abstract class for generating code for a method.  Subclasses
    should override definition_body to create the actual code.

    descriptor is the descriptor for the interface the method is associated with

    name is the name of the method as a string

    returnType is the IDLType of the return value

    args is a list of Argument objects

    inline should be True to generate an inline method, whose body is
    part of the declaration.

    alwaysInline should be True to generate an inline method annotated with
    MOZ_ALWAYS_INLINE.

    If templateArgs is not None it should be a list of strings containing
    template arguments, and the function will be templatized using those
    arguments.

    docs is None or documentation for the method in a string.
    """
    def __init__(self, descriptor, name, returnType, args, inline=False,
                 alwaysInline=False, extern=False, unsafe_fn=False, pub=False,
                 templateArgs=None, unsafe=False, docs=None, doesNotPanic=False):
        CGThing.__init__(self)
        self.descriptor = descriptor
        self.name = name
        self.returnType = returnType
        self.args = args
        self.alwaysInline = alwaysInline
        self.extern = extern
        self.unsafe_fn = extern or unsafe_fn
        self.templateArgs = templateArgs
        self.pub = pub
        self.unsafe = unsafe
        self.docs = docs
        self.catchPanic = self.extern and not doesNotPanic

    def _argstring(self):
        return ', '.join([a.declare() for a in self.args])

    def _template(self):
        if self.templateArgs is None:
            return ''
        return '<%s>\n' % ', '.join(self.templateArgs)

    def _docs(self):
        if self.docs is None:
            return ''

        lines = self.docs.splitlines()
        return ''.join('/// %s\n' % line for line in lines)

    def _decorators(self):
        decorators = []
        if self.alwaysInline:
            decorators.append('#[inline]')

        if self.pub:
            decorators.append('pub')

        if self.unsafe_fn:
            decorators.append('unsafe')

        if self.extern:
            decorators.append('extern')

        if not decorators:
            return ''
        return ' '.join(decorators) + ' '

    def _returnType(self):
        return (" -> %s" % self.returnType) if self.returnType != "void" else ""

    def define(self):
        body = self.definition_body()

        # Method will already be marked `unsafe` if `self.extern == True`
        if self.unsafe and not self.extern:
            body = CGWrapper(CGIndenter(body), pre="unsafe {\n", post="\n}")

        if self.catchPanic:
            body = CGWrapper(CGIndenter(body),
                             pre="let result = panic::catch_unwind(AssertUnwindSafe(|| {\n",
                             post=("""}));
match result {
    Ok(result) => result,
    Err(error) => {
        store_panic_result(error);
        return%s;
    }
}
""" % ("" if self.returnType == "void" else " false")))

        return CGWrapper(CGIndenter(body),
                         pre=self.definition_prologue(),
                         post=self.definition_epilogue()).define()

    def definition_prologue(self):
        return "%s%sfn %s%s(%s)%s {\n" % (self._docs(), self._decorators(),
                                          self.name, self._template(),
                                          self._argstring(), self._returnType())

    def definition_epilogue(self):
        return "\n}\n"

    def definition_body(self):
        raise NotImplementedError  # Override me!


class CGConstructorEnabled(CGAbstractMethod):
    """
    A method for testing whether we should be exposing this interface object.
    This can perform various tests depending on what conditions are specified
    on the interface.
    """
    def __init__(self, descriptor):
        CGAbstractMethod.__init__(self, descriptor,
                                  'ConstructorEnabled', 'bool',
                                  [Argument("*mut JSContext", "aCx"),
                                   Argument("HandleObject", "aObj")],
                                  unsafe_fn=True)

    def definition_body(self):
        conditions = []
        iface = self.descriptor.interface

        bits = " | ".join(sorted(
            "InterfaceObjectMap::" + camel_to_upper_snake(i) for i in iface.exposureSet
        ))
        conditions.append("is_exposed_in(aObj, %s)" % bits)

        pref = iface.getExtendedAttribute("Pref")
        if pref:
            assert isinstance(pref, list) and len(pref) == 1
            conditions.append('PREFS.get("%s").as_boolean().unwrap_or(false)' % pref[0])

        func = iface.getExtendedAttribute("Func")
        if func:
            assert isinstance(func, list) and len(func) == 1
            conditions.append("%s(aCx, aObj)" % func[0])

        return CGList((CGGeneric(cond) for cond in conditions), " &&\n")


def CreateBindingJSObject(descriptor, parent=None):
    create = "let raw = Box::into_raw(object);\nlet _rt = RootedTraceable::new(&*raw);\n"
    if descriptor.proxy:
        assert not descriptor.isGlobal()
        create += """
let handler = RegisterBindings::proxy_handlers[PrototypeList::Proxies::%s as usize];
rooted!(in(cx) let private = PrivateValue(raw as *const libc::c_void));
let obj = NewProxyObject(cx, handler,
                         private.handle(),
                         proto.get(), %s.get(),
                         ptr::null_mut(), ptr::null_mut());
assert!(!obj.is_null());
rooted!(in(cx) let obj = obj);\
""" % (descriptor.name, parent)
    elif descriptor.isGlobal():
        create += ("rooted!(in(cx) let obj =\n"
                   "    create_dom_global(\n"
                   "        cx,\n"
                   "        &Class.base as *const js::jsapi::Class as *const JSClass,\n"
                   "        raw as *const libc::c_void,\n"
                   "        Some(%s))\n"
                   ");\n"
                   "assert!(!obj.is_null());" % TRACE_HOOK_NAME)
    else:
        create += ("rooted!(in(cx) let obj = JS_NewObjectWithGivenProto(\n"
                   "    cx, &Class.base as *const js::jsapi::Class as *const JSClass, proto.handle()));\n"
                   "assert!(!obj.is_null());\n"
                   "\n"
                   "JS_SetReservedSlot(obj.get(), DOM_OBJECT_SLOT,\n"
                   "                   PrivateValue(raw as *const libc::c_void));")
    if descriptor.weakReferenceable:
        create += """
JS_SetReservedSlot(obj.get(), DOM_WEAK_SLOT, PrivateValue(ptr::null()));"""
    return create


def InitUnforgeablePropertiesOnHolder(descriptor, properties):
    """
    Define the unforgeable properties on the unforgeable holder for
    the interface represented by descriptor.

    properties is a PropertyArrays instance.
    """
    unforgeables = []

    defineUnforgeableAttrs = "define_guarded_properties(cx, unforgeable_holder.handle(), %s);"
    defineUnforgeableMethods = "define_guarded_methods(cx, unforgeable_holder.handle(), %s);"

    unforgeableMembers = [
        (defineUnforgeableAttrs, properties.unforgeable_attrs),
        (defineUnforgeableMethods, properties.unforgeable_methods),
    ]
    for template, array in unforgeableMembers:
        if array.length() > 0:
            unforgeables.append(CGGeneric(template % array.variableName()))
    return CGList(unforgeables, "\n")


def CopyUnforgeablePropertiesToInstance(descriptor):
    """
    Copy the unforgeable properties from the unforgeable holder for
    this interface to the instance object we have.
    """
    if not descriptor.hasUnforgeableMembers:
        return ""
    copyCode = ""

    # For proxies, we want to define on the expando object, not directly on the
    # reflector, so we can make sure we don't get confused by named getters.
    if descriptor.proxy:
        copyCode += """\
rooted!(in(cx) let expando = ensure_expando_object(cx, obj.handle()));
"""
        obj = "expando"
    else:
        obj = "obj"

    # We can't do the fast copy for globals, because we can't allocate the
    # unforgeable holder for those with the right JSClass. Luckily, there
    # aren't too many globals being created.
    if descriptor.isGlobal():
        copyFunc = "JS_CopyPropertiesFrom"
    else:
        copyFunc = "JS_InitializePropertiesFromCompatibleNativeObject"
    copyCode += """\
rooted!(in(cx) let mut unforgeable_holder = ptr::null_mut());
unforgeable_holder.handle_mut().set(
    JS_GetReservedSlot(proto.get(), DOM_PROTO_UNFORGEABLE_HOLDER_SLOT).to_object());
assert!(%(copyFunc)s(cx, %(obj)s.handle(), unforgeable_holder.handle()));
""" % {'copyFunc': copyFunc, 'obj': obj}

    return copyCode


class CGWrapMethod(CGAbstractMethod):
    """
    Class that generates the FooBinding::Wrap function for non-callback
    interfaces.
    """
    def __init__(self, descriptor):
        assert not descriptor.interface.isCallback()
        if not descriptor.isGlobal():
            args = [Argument('*mut JSContext', 'cx'), Argument('GlobalRef', 'scope'),
                    Argument("Box<%s>" % descriptor.concreteType, 'object')]
        else:
            args = [Argument('*mut JSContext', 'cx'),
                    Argument("Box<%s>" % descriptor.concreteType, 'object')]
        retval = 'Root<%s>' % descriptor.concreteType
        CGAbstractMethod.__init__(self, descriptor, 'Wrap', retval, args,
                                  pub=True, unsafe=True)

    def definition_body(self):
        unforgeable = CopyUnforgeablePropertiesToInstance(self.descriptor)
        if not self.descriptor.isGlobal():
            create = CreateBindingJSObject(self.descriptor, "scope")
            return CGGeneric("""\
let scope = scope.reflector().get_jsobject();
assert!(!scope.get().is_null());
assert!(((*JS_GetClass(scope.get())).flags & JSCLASS_IS_GLOBAL) != 0);

rooted!(in(cx) let mut proto = ptr::null_mut());
let _ac = JSAutoCompartment::new(cx, scope.get());
GetProtoObject(cx, scope, proto.handle_mut());
assert!(!proto.is_null());

%(createObject)s

%(copyUnforgeable)s
(*raw).init_reflector(obj.get());

Root::from_ref(&*raw)""" % {'copyUnforgeable': unforgeable, 'createObject': create})
        else:
            create = CreateBindingJSObject(self.descriptor)
            return CGGeneric("""\
%(createObject)s
(*raw).init_reflector(obj.get());

let _ac = JSAutoCompartment::new(cx, obj.get());
rooted!(in(cx) let mut proto = ptr::null_mut());
GetProtoObject(cx, obj.handle(), proto.handle_mut());
JS_SetPrototype(cx, obj.handle(), proto.handle());

%(copyUnforgeable)s

Root::from_ref(&*raw)\
""" % {'copyUnforgeable': unforgeable, 'createObject': create})


class CGIDLInterface(CGThing):
    """
    Class for codegen of an implementation of the IDLInterface trait.
    """
    def __init__(self, descriptor):
        CGThing.__init__(self)
        self.descriptor = descriptor

    def define(self):
        interface = self.descriptor.interface
        name = self.descriptor.name
        if (interface.getUserData("hasConcreteDescendant", False) or
                interface.getUserData("hasProxyDescendant", False)):
            depth = self.descriptor.prototypeDepth
            check = "class.interface_chain[%s] == PrototypeList::ID::%s" % (depth, name)
        elif self.descriptor.proxy:
            check = "class as *const _ == &Class as *const _"
        else:
            check = "class as *const _ == &Class.dom_class as *const _"
        return """\
impl IDLInterface for %(name)s {
    #[inline]
    fn derives(class: &'static DOMClass) -> bool {
        %(check)s
    }
}

impl PartialEq for %(name)s {
    fn eq(&self, other: &%(name)s) -> bool {
        self as *const %(name)s == &*other
    }
}
""" % {'check': check, 'name': name}


class CGAbstractExternMethod(CGAbstractMethod):
    """
    Abstract base class for codegen of implementation-only (no
    declaration) static methods.
    """
    def __init__(self, descriptor, name, returnType, args, doesNotPanic=False):
        CGAbstractMethod.__init__(self, descriptor, name, returnType, args,
                                  inline=False, extern=True, doesNotPanic=doesNotPanic)


class PropertyArrays():
    def __init__(self, descriptor):
        self.static_methods = MethodDefiner(descriptor, "StaticMethods",
                                            static=True, unforgeable=False)
        self.static_attrs = AttrDefiner(descriptor, "StaticAttributes",
                                        static=True, unforgeable=False)
        self.methods = MethodDefiner(descriptor, "Methods", static=False, unforgeable=False)
        self.unforgeable_methods = MethodDefiner(descriptor, "UnforgeableMethods",
                                                 static=False, unforgeable=True)
        self.attrs = AttrDefiner(descriptor, "Attributes", static=False, unforgeable=False)
        self.unforgeable_attrs = AttrDefiner(descriptor, "UnforgeableAttributes",
                                             static=False, unforgeable=True)
        self.consts = ConstDefiner(descriptor, "Constants")
        pass

    @staticmethod
    def arrayNames():
        return [
            "static_methods",
            "static_attrs",
            "methods",
            "unforgeable_methods",
            "attrs",
            "unforgeable_attrs",
            "consts",
        ]

    def variableNames(self):
        names = {}
        for array in self.arrayNames():
            names[array] = getattr(self, array).variableName()
        return names

    def __str__(self):
        define = ""
        for array in self.arrayNames():
            define += str(getattr(self, array))
        return define


class CGCreateInterfaceObjectsMethod(CGAbstractMethod):
    """
    Generate the CreateInterfaceObjects method for an interface descriptor.

    properties should be a PropertyArrays instance.
    """
    def __init__(self, descriptor, properties, haveUnscopables):
        args = [Argument('*mut JSContext', 'cx'), Argument('HandleObject', 'global'),
                Argument('*mut ProtoOrIfaceArray', 'cache')]
        CGAbstractMethod.__init__(self, descriptor, 'CreateInterfaceObjects', 'void', args,
                                  unsafe=True)
        self.properties = properties
        self.haveUnscopables = haveUnscopables

    def definition_body(self):
        name = self.descriptor.interface.identifier.name
        if self.descriptor.interface.isCallback():
            assert not self.descriptor.interface.ctor() and self.descriptor.interface.hasConstants()
            return CGGeneric("""\
rooted!(in(cx) let mut interface = ptr::null_mut());
create_callback_interface_object(cx, global, sConstants, %(name)s, interface.handle_mut());
assert!(!interface.is_null());
assert!((*cache)[PrototypeList::Constructor::%(id)s as usize].is_null());
(*cache)[PrototypeList::Constructor::%(id)s as usize] = interface.get();
<*mut JSObject>::post_barrier((*cache).as_mut_ptr().offset(PrototypeList::Constructor::%(id)s as isize),
                              ptr::null_mut(),
                              interface.get());
""" % {"id": name, "name": str_to_const_array(name)})

        if len(self.descriptor.prototypeChain) == 1:
            if self.descriptor.interface.getExtendedAttribute("ExceptionClass"):
                getPrototypeProto = "prototype_proto.set(JS_GetErrorPrototype(cx))"
            else:
                getPrototypeProto = "prototype_proto.set(JS_GetObjectPrototype(cx, global))"
        else:
            getPrototypeProto = ("%s::GetProtoObject(cx, global, prototype_proto.handle_mut())" %
                                 toBindingNamespace(self.descriptor.prototypeChain[-2]))

        code = [CGGeneric("""\
rooted!(in(cx) let mut prototype_proto = ptr::null_mut());
%s;
assert!(!prototype_proto.is_null());""" % getPrototypeProto)]

        properties = {
            "id": name,
            "unscopables": "unscopable_names" if self.haveUnscopables else "&[]"
        }
        for arrayName in self.properties.arrayNames():
            array = getattr(self.properties, arrayName)
            if array.length():
                properties[arrayName] = array.variableName()
            else:
                properties[arrayName] = "&[]"

        code.append(CGGeneric("""
rooted!(in(cx) let mut prototype = ptr::null_mut());
create_interface_prototype_object(cx,
                                  prototype_proto.handle(),
                                  &PrototypeClass,
                                  %(methods)s,
                                  %(attrs)s,
                                  %(consts)s,
                                  %(unscopables)s,
                                  prototype.handle_mut());
assert!(!prototype.is_null());
assert!((*cache)[PrototypeList::ID::%(id)s as usize].is_null());
(*cache)[PrototypeList::ID::%(id)s as usize] = prototype.get();
<*mut JSObject>::post_barrier((*cache).as_mut_ptr().offset(PrototypeList::ID::%(id)s as isize),
                              ptr::null_mut(),
                              prototype.get());
""" % properties))

        if self.descriptor.interface.hasInterfaceObject():
            properties["name"] = str_to_const_array(name)
            if self.descriptor.interface.ctor():
                properties["length"] = methodLength(self.descriptor.interface.ctor())
            else:
                properties["length"] = 0
            if self.descriptor.interface.parent:
                parentName = toBindingNamespace(self.descriptor.getParentName())
                code.append(CGGeneric("""
rooted!(in(cx) let mut interface_proto = ptr::null_mut());
%s::GetConstructorObject(cx, global, interface_proto.handle_mut());""" % parentName))
            else:
                code.append(CGGeneric("""
rooted!(in(cx) let interface_proto = JS_GetFunctionPrototype(cx, global));"""))
            code.append(CGGeneric("""\
assert!(!interface_proto.is_null());

rooted!(in(cx) let mut interface = ptr::null_mut());
create_noncallback_interface_object(cx,
                                    global,
                                    interface_proto.handle(),
                                    &InterfaceObjectClass,
                                    %(static_methods)s,
                                    %(static_attrs)s,
                                    %(consts)s,
                                    prototype.handle(),
                                    %(name)s,
                                    %(length)s,
                                    interface.handle_mut());
assert!(!interface.is_null());""" % properties))
            if self.descriptor.hasDescendants():
                code.append(CGGeneric("""\
assert!((*cache)[PrototypeList::Constructor::%(id)s as usize].is_null());
(*cache)[PrototypeList::Constructor::%(id)s as usize] = interface.get();
<*mut JSObject>::post_barrier((*cache).as_mut_ptr().offset(PrototypeList::Constructor::%(id)s as isize),
                              ptr::null_mut(),
                              interface.get());
""" % properties))

        constructors = self.descriptor.interface.namedConstructors
        if constructors:
            decl = "let named_constructors: [(NonNullJSNative, &'static [u8], u32); %d]" % len(constructors)
            specs = []
            for constructor in constructors:
                hook = CONSTRUCT_HOOK_NAME + "_" + constructor.identifier.name
                name = str_to_const_array(constructor.identifier.name)
                length = methodLength(constructor)
                specs.append(CGGeneric("(%s as NonNullJSNative, %s, %d)" % (hook, name, length)))
            values = CGIndenter(CGList(specs, "\n"), 4)
            code.append(CGWrapper(values, pre="%s = [\n" % decl, post="\n];"))
            code.append(CGGeneric("create_named_constructors(cx, global, &named_constructors, prototype.handle());"))

        if self.descriptor.hasUnforgeableMembers:
            # We want to use the same JSClass and prototype as the object we'll
            # end up defining the unforgeable properties on in the end, so that
            # we can use JS_InitializePropertiesFromCompatibleNativeObject to do
            # a fast copy.  In the case of proxies that's null, because the
            # expando object is a vanilla object, but in the case of other DOM
            # objects it's whatever our class is.
            #
            # Also, for a global we can't use the global's class; just use
            # nullpr and when we do the copy off the holder we'll take a slower
            # path.  This also means that we don't need to worry about matching
            # the prototype.
            if self.descriptor.proxy or self.descriptor.isGlobal():
                holderClass = "ptr::null()"
                holderProto = "HandleObject::null()"
            else:
                holderClass = "&Class.base as *const js::jsapi::Class as *const JSClass"
                holderProto = "prototype.handle()"
            code.append(CGGeneric("""
rooted!(in(cx) let mut unforgeable_holder = ptr::null_mut());
unforgeable_holder.handle_mut().set(
    JS_NewObjectWithoutMetadata(cx, %(holderClass)s, %(holderProto)s));
assert!(!unforgeable_holder.is_null());
""" % {'holderClass': holderClass, 'holderProto': holderProto}))
            code.append(InitUnforgeablePropertiesOnHolder(self.descriptor, self.properties))
            code.append(CGGeneric("""\
JS_SetReservedSlot(prototype.get(), DOM_PROTO_UNFORGEABLE_HOLDER_SLOT,
                   ObjectValue(&*unforgeable_holder.get()))"""))

        return CGList(code, "\n")


class CGGetPerInterfaceObject(CGAbstractMethod):
    """
    A method for getting a per-interface object (a prototype object or interface
    constructor object).
    """
    def __init__(self, descriptor, name, idPrefix="", pub=False):
        args = [Argument('*mut JSContext', 'cx'),
                Argument('HandleObject', 'global'),
                Argument('MutableHandleObject', 'rval')]
        CGAbstractMethod.__init__(self, descriptor, name,
                                  'void', args, pub=pub, unsafe=True)
        self.id = idPrefix + "::" + self.descriptor.name

    def definition_body(self):
        return CGGeneric("""
assert!(((*JS_GetClass(global.get())).flags & JSCLASS_DOM_GLOBAL) != 0);

/* Check to see whether the interface objects are already installed */
let proto_or_iface_array = get_proto_or_iface_array(global.get());
rval.set((*proto_or_iface_array)[%(id)s as usize]);
if !rval.get().is_null() {
    return;
}

CreateInterfaceObjects(cx, global, proto_or_iface_array);
rval.set((*proto_or_iface_array)[%(id)s as usize]);
assert!(!rval.get().is_null());
""" % {"id": self.id})


class CGGetProtoObjectMethod(CGGetPerInterfaceObject):
    """
    A method for getting the interface prototype object.
    """
    def __init__(self, descriptor):
        CGGetPerInterfaceObject.__init__(self, descriptor, "GetProtoObject",
                                         "PrototypeList::ID", pub=descriptor.hasDescendants())

    def definition_body(self):
        return CGList([
            CGGeneric("""\
/* Get the interface prototype object for this class.  This will create the
   object as needed. */"""),
            CGGetPerInterfaceObject.definition_body(self),
        ])


class CGGetConstructorObjectMethod(CGGetPerInterfaceObject):
    """
    A method for getting the interface constructor object.
    """
    def __init__(self, descriptor):
        CGGetPerInterfaceObject.__init__(self, descriptor, "GetConstructorObject",
                                         "PrototypeList::Constructor",
                                         pub=descriptor.hasDescendants())

    def definition_body(self):
        return CGList([
            CGGeneric("""\
/* Get the interface object for this class.  This will create the object as
   needed. */"""),
            CGGetPerInterfaceObject.definition_body(self),
        ])


class CGDefineProxyHandler(CGAbstractMethod):
    """
    A method to create and cache the proxy trap for a given interface.
    """
    def __init__(self, descriptor):
        assert descriptor.proxy
        CGAbstractMethod.__init__(self, descriptor, 'DefineProxyHandler',
                                  '*const libc::c_void', [],
                                  pub=True, unsafe=True)

    def define(self):
        return CGAbstractMethod.define(self)

    def definition_body(self):
        customDefineProperty = 'proxyhandler::define_property'
        if self.descriptor.operations['IndexedSetter'] or self.descriptor.operations['NamedSetter']:
            customDefineProperty = 'defineProperty'

        customDelete = 'proxyhandler::delete'
        if self.descriptor.operations['NamedDeleter']:
            customDelete = 'delete'

        getOwnEnumerablePropertyKeys = "own_property_keys"
        if self.descriptor.interface.getExtendedAttribute("LegacyUnenumerableNamedProperties"):
            getOwnEnumerablePropertyKeys = "getOwnEnumerablePropertyKeys"

        args = {
            "defineProperty": customDefineProperty,
            "delete": customDelete,
            "getOwnEnumerablePropertyKeys": getOwnEnumerablePropertyKeys,
            "trace": TRACE_HOOK_NAME,
            "finalize": FINALIZE_HOOK_NAME,
        }

        return CGGeneric("""\
let traps = ProxyTraps {
    enter: None,
    getOwnPropertyDescriptor: Some(getOwnPropertyDescriptor),
    defineProperty: Some(%(defineProperty)s),
    ownPropertyKeys: Some(own_property_keys),
    delete_: Some(%(delete)s),
    enumerate: None,
    getPrototypeIfOrdinary: Some(proxyhandler::get_prototype_if_ordinary),
    preventExtensions: Some(proxyhandler::prevent_extensions),
    isExtensible: Some(proxyhandler::is_extensible),
    has: None,
    get: Some(get),
    set: None,
    call: None,
    construct: None,
    getPropertyDescriptor: Some(get_property_descriptor),
    hasOwn: Some(hasOwn),
    getOwnEnumerablePropertyKeys: Some(%(getOwnEnumerablePropertyKeys)s),
    nativeCall: None,
    hasInstance: None,
    objectClassIs: None,
    className: Some(className),
    fun_toString: None,
    boxedValue_unbox: None,
    defaultValue: None,
    trace: Some(%(trace)s),
    finalize: Some(%(finalize)s),
    objectMoved: None,
    isCallable: None,
    isConstructor: None,
};

CreateProxyHandler(&traps, &Class as *const _ as *const _)\
""" % args)


class CGDefineDOMInterfaceMethod(CGAbstractMethod):
    """
    A method for resolve hooks to try to lazily define the interface object for
    a given interface.
    """
    def __init__(self, descriptor):
        assert descriptor.interface.hasInterfaceObject()
        args = [
            Argument('*mut JSContext', 'cx'),
            Argument('HandleObject', 'global'),
        ]
        CGAbstractMethod.__init__(self, descriptor, 'DefineDOMInterface',
                                  'void', args, pub=True, unsafe_fn=True)

    def define(self):
        return CGAbstractMethod.define(self)

    def definition_body(self):
        if self.descriptor.interface.isCallback():
            function = "GetConstructorObject"
        else:
            function = "GetProtoObject"
        return CGGeneric("""\
assert!(!global.get().is_null());

if !ConstructorEnabled(cx, global) {
    return;
}

rooted!(in(cx) let mut proto = ptr::null_mut());
%s(cx, global, proto.handle_mut());
assert!(!proto.is_null());""" % (function,))


def needCx(returnType, arguments, considerTypes):
    return (considerTypes and
            (typeNeedsCx(returnType, True) or
             any(typeNeedsCx(a.type) for a in arguments)))


class CGCallGenerator(CGThing):
    """
    A class to generate an actual call to a C++ object.  Assumes that the C++
    object is stored in a variable whose name is given by the |object| argument.

    errorResult should be a string for the value to return in case of an
    exception from the native code, or None if no error reporting is needed.
    """
    def __init__(self, errorResult, arguments, argsPre, returnType,
                 extendedAttributes, descriptorProvider, nativeMethodName,
                 static, object="this"):
        CGThing.__init__(self)

        assert errorResult is None or isinstance(errorResult, str)

        isFallible = errorResult is not None

        result = getRetvalDeclarationForType(returnType, descriptorProvider)
        if isFallible:
            result = CGWrapper(result, pre="Result<", post=", Error>")

        args = CGList([CGGeneric(arg) for arg in argsPre], ", ")
        for (a, name) in arguments:
            # XXXjdm Perhaps we should pass all nontrivial types by borrowed pointer
            if a.type.isDictionary():
                name = "&" + name
            args.append(CGGeneric(name))

        needsCx = needCx(returnType, (a for (a, _) in arguments), True)

        if "cx" not in argsPre and needsCx:
            args.prepend(CGGeneric("cx"))

        # Build up our actual call
        self.cgRoot = CGList([], "\n")

        call = CGGeneric(nativeMethodName)
        if static:
            call = CGWrapper(call, pre="%s::" % descriptorProvider.interface.identifier.name)
        else:
            call = CGWrapper(call, pre="%s." % object)
        call = CGList([call, CGWrapper(args, pre="(", post=")")])

        self.cgRoot.append(CGList([
            CGGeneric("let result: "),
            result,
            CGGeneric(" = "),
            call,
            CGGeneric(";"),
        ]))

        if isFallible:
            if static:
                glob = ""
            else:
                glob = "        let global = global_root_from_reflector(this);\n"

            self.cgRoot.append(CGGeneric(
                "let result = match result {\n"
                "    Ok(result) => result,\n"
                "    Err(e) => {\n"
                "%s"
                "        throw_dom_exception(cx, global.r(), e);\n"
                "        return%s;\n"
                "    },\n"
                "};" % (glob, errorResult)))

    def define(self):
        return self.cgRoot.define()


class CGPerSignatureCall(CGThing):
    """
    This class handles the guts of generating code for a particular
    call signature.  A call signature consists of four things:

    1) A return type, which can be None to indicate that there is no
       actual return value (e.g. this is an attribute setter) or an
       IDLType if there's an IDL type involved (including |void|).
    2) An argument list, which is allowed to be empty.
    3) A name of a native method to call.
    4) Whether or not this method is static.

    We also need to know whether this is a method or a getter/setter
    to do error reporting correctly.

    The idlNode parameter can be either a method or an attr. We can query
    |idlNode.identifier| in both cases, so we can be agnostic between the two.
    """
    # XXXbz For now each entry in the argument list is either an
    # IDLArgument or a FakeArgument, but longer-term we may want to
    # have ways of flagging things like JSContext* or optional_argc in
    # there.

    def __init__(self, returnType, argsPre, arguments, nativeMethodName, static,
                 descriptor, idlNode, argConversionStartsAt=0,
                 getter=False, setter=False):
        CGThing.__init__(self)
        self.returnType = returnType
        self.descriptor = descriptor
        self.idlNode = idlNode
        self.extendedAttributes = descriptor.getExtendedAttributes(idlNode,
                                                                   getter=getter,
                                                                   setter=setter)
        self.argsPre = argsPre
        self.arguments = arguments
        self.argCount = len(arguments)
        cgThings = []
        cgThings.extend([CGArgumentConverter(arguments[i], i, self.getArgs(),
                                             self.getArgc(), self.descriptor,
                                             invalidEnumValueFatal=not setter) for
                         i in range(argConversionStartsAt, self.argCount)])

        errorResult = None
        if self.isFallible():
            errorResult = " false"

        cgThings.append(CGCallGenerator(
            errorResult,
            self.getArguments(), self.argsPre, returnType,
            self.extendedAttributes, descriptor, nativeMethodName,
            static))
        self.cgRoot = CGList(cgThings, "\n")

    def getArgs(self):
        return "args" if self.argCount > 0 else ""

    def getArgc(self):
        return "argc"

    def getArguments(self):
        def process(arg, i):
            argVal = "arg" + str(i)
            if arg.type.isGeckoInterface() and not arg.type.unroll().inner.isCallback():
                argVal += ".r()"
            return argVal
        return [(a, process(a, i)) for (i, a) in enumerate(self.arguments)]

    def isFallible(self):
        return 'infallible' not in self.extendedAttributes

    def wrap_return_value(self):
        return wrapForType('args.rval()')

    def define(self):
        return (self.cgRoot.define() + "\n" + self.wrap_return_value())


class CGSwitch(CGList):
    """
    A class to generate code for a switch statement.

    Takes three constructor arguments: an expression, a list of cases,
    and an optional default.

    Each case is a CGCase.  The default is a CGThing for the body of
    the default case, if any.
    """
    def __init__(self, expression, cases, default=None):
        CGList.__init__(self, [CGIndenter(c) for c in cases], "\n")
        self.prepend(CGWrapper(CGGeneric(expression),
                               pre="match ", post=" {"))
        if default is not None:
            self.append(
                CGIndenter(
                    CGWrapper(
                        CGIndenter(default),
                        pre="_ => {\n",
                        post="\n}"
                    )
                )
            )

        self.append(CGGeneric("}"))


class CGCase(CGList):
    """
    A class to generate code for a case statement.

    Takes three constructor arguments: an expression, a CGThing for
    the body (allowed to be None if there is no body), and an optional
    argument (defaulting to False) for whether to fall through.
    """
    def __init__(self, expression, body, fallThrough=False):
        CGList.__init__(self, [], "\n")
        self.append(CGWrapper(CGGeneric(expression), post=" => {"))
        bodyList = CGList([body], "\n")
        if fallThrough:
            raise TypeError("fall through required but unsupported")
            # bodyList.append(CGGeneric('panic!("fall through unsupported"); /* Fall through */'))
        self.append(CGIndenter(bodyList))
        self.append(CGGeneric("}"))


class CGGetterCall(CGPerSignatureCall):
    """
    A class to generate a native object getter call for a particular IDL
    getter.
    """
    def __init__(self, argsPre, returnType, nativeMethodName, descriptor, attr):
        CGPerSignatureCall.__init__(self, returnType, argsPre, [],
                                    nativeMethodName, attr.isStatic(), descriptor,
                                    attr, getter=True)


class FakeArgument():
    """
    A class that quacks like an IDLArgument.  This is used to make
    setters look like method calls or for special operations.
    """
    def __init__(self, type, interfaceMember, allowTreatNonObjectAsNull=False):
        self.type = type
        self.optional = False
        self.variadic = False
        self.defaultValue = None
        self._allowTreatNonObjectAsNull = allowTreatNonObjectAsNull
        self.treatNullAs = interfaceMember.treatNullAs
        self.enforceRange = False
        self.clamp = False

    def allowTreatNonCallableAsNull(self):
        return self._allowTreatNonObjectAsNull


class CGSetterCall(CGPerSignatureCall):
    """
    A class to generate a native object setter call for a particular IDL
    setter.
    """
    def __init__(self, argsPre, argType, nativeMethodName, descriptor, attr):
        CGPerSignatureCall.__init__(self, None, argsPre,
                                    [FakeArgument(argType, attr, allowTreatNonObjectAsNull=True)],
                                    nativeMethodName, attr.isStatic(), descriptor, attr,
                                    setter=True)

    def wrap_return_value(self):
        # We have no return value
        return "\nreturn true;"

    def getArgc(self):
        return "1"


class CGAbstractStaticBindingMethod(CGAbstractMethod):
    """
    Common class to generate the JSNatives for all our static methods, getters
    and setters.  This will generate the function declaration and unwrap the
    global object.  Subclasses are expected to override the generate_code
    function to do the rest of the work.  This function should return a
    CGThing which is already properly indented.
    """
    def __init__(self, descriptor, name):
        args = [
            Argument('*mut JSContext', 'cx'),
            Argument('libc::c_uint', 'argc'),
            Argument('*mut JSVal', 'vp'),
        ]
        CGAbstractMethod.__init__(self, descriptor, name, "bool", args, extern=True)

    def definition_body(self):
        preamble = CGGeneric("""\
let global = global_root_from_object(JS_CALLEE(cx, vp).to_object());
""")
        return CGList([preamble, self.generate_code()])

    def generate_code(self):
        raise NotImplementedError  # Override me!


class CGSpecializedMethod(CGAbstractExternMethod):
    """
    A class for generating the C++ code for a specialized method that the JIT
    can call with lower overhead.
    """
    def __init__(self, descriptor, method):
        self.method = method
        name = method.identifier.name
        args = [Argument('*mut JSContext', 'cx'), Argument('HandleObject', '_obj'),
                Argument('*const %s' % descriptor.concreteType, 'this'),
                Argument('*const JSJitMethodCallArgs', 'args')]
        CGAbstractExternMethod.__init__(self, descriptor, name, 'bool', args)

    def definition_body(self):
        nativeName = CGSpecializedMethod.makeNativeName(self.descriptor,
                                                        self.method)
        return CGWrapper(CGMethodCall([], nativeName, self.method.isStatic(),
                                      self.descriptor, self.method),
                         pre="let this = &*this;\n"
                             "let args = &*args;\n"
                             "let argc = args._base.argc_;\n")

    @staticmethod
    def makeNativeName(descriptor, method):
        name = method.identifier.name
        nativeName = descriptor.binaryNameFor(name)
        if nativeName == name:
            nativeName = descriptor.internalNameFor(name)
        return MakeNativeName(nativeName)


class CGStaticMethod(CGAbstractStaticBindingMethod):
    """
    A class for generating the Rust code for an IDL static method.
    """
    def __init__(self, descriptor, method):
        self.method = method
        name = method.identifier.name
        CGAbstractStaticBindingMethod.__init__(self, descriptor, name)

    def generate_code(self):
        nativeName = CGSpecializedMethod.makeNativeName(self.descriptor,
                                                        self.method)
        setupArgs = CGGeneric("let args = CallArgs::from_vp(vp, argc);\n")
        call = CGMethodCall(["global.r()"], nativeName, True, self.descriptor, self.method)
        return CGList([setupArgs, call])


class CGSpecializedGetter(CGAbstractExternMethod):
    """
    A class for generating the code for a specialized attribute getter
    that the JIT can call with lower overhead.
    """
    def __init__(self, descriptor, attr):
        self.attr = attr
        name = 'get_' + descriptor.internalNameFor(attr.identifier.name)
        args = [Argument('*mut JSContext', 'cx'),
                Argument('HandleObject', '_obj'),
                Argument('*const %s' % descriptor.concreteType, 'this'),
                Argument('JSJitGetterCallArgs', 'args')]
        CGAbstractExternMethod.__init__(self, descriptor, name, "bool", args)

    def definition_body(self):
        nativeName = CGSpecializedGetter.makeNativeName(self.descriptor,
                                                        self.attr)

        return CGWrapper(CGGetterCall([], self.attr.type, nativeName,
                                      self.descriptor, self.attr),
                         pre="let this = &*this;\n")

    @staticmethod
    def makeNativeName(descriptor, attr):
        name = attr.identifier.name
        nativeName = descriptor.binaryNameFor(name)
        if nativeName == name:
            nativeName = descriptor.internalNameFor(name)
        nativeName = MakeNativeName(nativeName)
        infallible = ('infallible' in
                      descriptor.getExtendedAttributes(attr, getter=True))
        if attr.type.nullable() or not infallible:
            return "Get" + nativeName

        return nativeName


class CGStaticGetter(CGAbstractStaticBindingMethod):
    """
    A class for generating the C++ code for an IDL static attribute getter.
    """
    def __init__(self, descriptor, attr):
        self.attr = attr
        name = 'get_' + attr.identifier.name
        CGAbstractStaticBindingMethod.__init__(self, descriptor, name)

    def generate_code(self):
        nativeName = CGSpecializedGetter.makeNativeName(self.descriptor,
                                                        self.attr)
        setupArgs = CGGeneric("let args = CallArgs::from_vp(vp, argc);\n")
        call = CGGetterCall(["global.r()"], self.attr.type, nativeName, self.descriptor,
                            self.attr)
        return CGList([setupArgs, call])


class CGSpecializedSetter(CGAbstractExternMethod):
    """
    A class for generating the code for a specialized attribute setter
    that the JIT can call with lower overhead.
    """
    def __init__(self, descriptor, attr):
        self.attr = attr
        name = 'set_' + descriptor.internalNameFor(attr.identifier.name)
        args = [Argument('*mut JSContext', 'cx'),
                Argument('HandleObject', 'obj'),
                Argument('*const %s' % descriptor.concreteType, 'this'),
                Argument('JSJitSetterCallArgs', 'args')]
        CGAbstractExternMethod.__init__(self, descriptor, name, "bool", args)

    def definition_body(self):
        nativeName = CGSpecializedSetter.makeNativeName(self.descriptor,
                                                        self.attr)
        return CGWrapper(CGSetterCall([], self.attr.type, nativeName,
                                      self.descriptor, self.attr),
                         pre="let this = &*this;\n")

    @staticmethod
    def makeNativeName(descriptor, attr):
        name = attr.identifier.name
        nativeName = descriptor.binaryNameFor(name)
        if nativeName == name:
            nativeName = descriptor.internalNameFor(name)
        return "Set" + MakeNativeName(nativeName)


class CGStaticSetter(CGAbstractStaticBindingMethod):
    """
    A class for generating the C++ code for an IDL static attribute setter.
    """
    def __init__(self, descriptor, attr):
        self.attr = attr
        name = 'set_' + attr.identifier.name
        CGAbstractStaticBindingMethod.__init__(self, descriptor, name)

    def generate_code(self):
        nativeName = CGSpecializedSetter.makeNativeName(self.descriptor,
                                                        self.attr)
        checkForArg = CGGeneric(
            "let args = CallArgs::from_vp(vp, argc);\n"
            "if argc == 0 {\n"
            "    throw_type_error(cx, \"Not enough arguments to %s setter.\");\n"
            "    return false;\n"
            "}" % self.attr.identifier.name)
        call = CGSetterCall(["global.r()"], self.attr.type, nativeName, self.descriptor,
                            self.attr)
        return CGList([checkForArg, call])


class CGSpecializedForwardingSetter(CGSpecializedSetter):
    """
    A class for generating the code for an IDL attribute forwarding setter.
    """
    def __init__(self, descriptor, attr):
        CGSpecializedSetter.__init__(self, descriptor, attr)

    def definition_body(self):
        attrName = self.attr.identifier.name
        forwardToAttrName = self.attr.getExtendedAttribute("PutForwards")[0]
        # JS_GetProperty and JS_SetProperty can only deal with ASCII
        assert all(ord(c) < 128 for c in attrName)
        assert all(ord(c) < 128 for c in forwardToAttrName)
        return CGGeneric("""\
rooted!(in(cx) let mut v = UndefinedValue());
if !JS_GetProperty(cx, obj, %s as *const u8 as *const libc::c_char, v.handle_mut()) {
    return false;
}
if !v.is_object() {
    throw_type_error(cx, "Value.%s is not an object.");
    return false;
}
rooted!(in(cx) let target_obj = v.to_object());
JS_SetProperty(cx, target_obj.handle(), %s as *const u8 as *const libc::c_char, args.get(0))
""" % (str_to_const_array(attrName), attrName, str_to_const_array(forwardToAttrName)))


class CGMemberJITInfo(CGThing):
    """
    A class for generating the JITInfo for a property that points to
    our specialized getter and setter.
    """
    def __init__(self, descriptor, member):
        self.member = member
        self.descriptor = descriptor

    def defineJitInfo(self, infoName, opName, opType, infallible, movable,
                      aliasSet, alwaysInSlot, lazilyInSlot, slotIndex,
                      returnTypes, args):
        """
        aliasSet is a JSJitInfo_AliasSet value, without the "JSJitInfo_AliasSet::" bit.

        args is None if we don't want to output argTypes for some
        reason (e.g. we have overloads or we're not a method) and
        otherwise an iterable of the arguments for this method.
        """
        assert not movable or aliasSet != "AliasEverything"  # Can't move write-aliasing things
        assert not alwaysInSlot or movable  # Things always in slots had better be movable

        def jitInfoInitializer(isTypedMethod):
            initializer = fill(
                """
                JSJitInfo {
                    call: ${opName} as *const os::raw::c_void,
                    protoID: PrototypeList::ID::${name} as u16,
                    depth: ${depth},
                    _bitfield_1:
                        JSJitInfo::new_bitfield_1(
                            JSJitInfo_OpType::${opType} as u8,
                            JSJitInfo_AliasSet::${aliasSet} as u8,
                            JSValueType::${returnType} as u8,
                            ${isInfallible},
                            ${isMovable},
                            ${isEliminatable},
                            ${isAlwaysInSlot},
                            ${isLazilyCachedInSlot},
                            ${isTypedMethod},
                            ${slotIndex} as u16,
                        )
                }
                """,
                opName=opName,
                name=self.descriptor.name,
                depth=self.descriptor.interface.inheritanceDepth(),
                opType=opType,
                aliasSet=aliasSet,
                returnType=reduce(CGMemberJITInfo.getSingleReturnType, returnTypes,
                                  ""),
                isInfallible=toStringBool(infallible),
                isMovable=toStringBool(movable),
                # FIXME(nox): https://github.com/servo/servo/issues/10991
                isEliminatable=toStringBool(False),
                isAlwaysInSlot=toStringBool(alwaysInSlot),
                isLazilyCachedInSlot=toStringBool(lazilyInSlot),
                isTypedMethod=toStringBool(isTypedMethod),
                slotIndex=slotIndex)
            return initializer.rstrip()

        if args is not None:
            argTypes = "%s_argTypes" % infoName
            args = [CGMemberJITInfo.getJSArgType(arg.type) for arg in args]
            args.append("JSJitInfo_ArgType::ArgTypeListEnd as i32")
            argTypesDecl = (
                "const %s: [i32; %d] = [ %s ];\n" %
                (argTypes, len(args), ", ".join(args)))
            return fill(
                """
                $*{argTypesDecl}
                const ${infoName}: JSTypedMethodJitInfo = JSTypedMethodJitInfo {
                    base: ${jitInfo},
                    argTypes: &${argTypes} as *const _ as *const JSJitInfo_ArgType,
                };
                """,
                argTypesDecl=argTypesDecl,
                infoName=infoName,
                jitInfo=indent(jitInfoInitializer(True)),
                argTypes=argTypes)

        return ("\n"
                "const %s: JSJitInfo = %s;\n"
                % (infoName, jitInfoInitializer(False)))

    def define(self):
        if self.member.isAttr():
            internalMemberName = self.descriptor.internalNameFor(self.member.identifier.name)
            getterinfo = ("%s_getterinfo" % internalMemberName)
            getter = ("get_%s" % internalMemberName)
            getterinfal = "infallible" in self.descriptor.getExtendedAttributes(self.member, getter=True)

            movable = self.mayBeMovable() and getterinfal
            aliasSet = self.aliasSet()

            isAlwaysInSlot = self.member.getExtendedAttribute("StoreInSlot")
            if self.member.slotIndices is not None:
                assert isAlwaysInSlot or self.member.getExtendedAttribute("Cached")
                isLazilyCachedInSlot = not isAlwaysInSlot
                slotIndex = memberReservedSlot(self.member)  # noqa:FIXME: memberReservedSlot is not defined
                # We'll statically assert that this is not too big in
                # CGUpdateMemberSlotsMethod, in the case when
                # isAlwaysInSlot is true.
            else:
                isLazilyCachedInSlot = False
                slotIndex = "0"

            result = self.defineJitInfo(getterinfo, getter, "Getter",
                                        getterinfal, movable, aliasSet,
                                        isAlwaysInSlot, isLazilyCachedInSlot,
                                        slotIndex,
                                        [self.member.type], None)
            if (not self.member.readonly or self.member.getExtendedAttribute("PutForwards")):
                setterinfo = ("%s_setterinfo" % internalMemberName)
                setter = ("set_%s" % internalMemberName)
                # Setters are always fallible, since they have to do a typed unwrap.
                result += self.defineJitInfo(setterinfo, setter, "Setter",
                                             False, False, "AliasEverything",
                                             False, False, "0",
                                             [BuiltinTypes[IDLBuiltinType.Types.void]],
                                             None)
            return result
        if self.member.isMethod():
            methodinfo = ("%s_methodinfo" % self.member.identifier.name)
            method = ("%s" % self.member.identifier.name)

            # Methods are infallible if they are infallible, have no arguments
            # to unwrap, and have a return type that's infallible to wrap up for
            # return.
            sigs = self.member.signatures()
            if len(sigs) != 1:
                # Don't handle overloading. If there's more than one signature,
                # one of them must take arguments.
                methodInfal = False
                args = None
                movable = False
            else:
                sig = sigs[0]
                # For methods that affect nothing, it's OK to set movable to our
                # notion of infallible on the C++ side, without considering
                # argument conversions, since argument conversions that can
                # reliably throw would be effectful anyway and the jit doesn't
                # move effectful things.
                hasInfallibleImpl = "infallible" in self.descriptor.getExtendedAttributes(self.member)
                movable = self.mayBeMovable() and hasInfallibleImpl
                # XXXbz can we move the smarts about fallibility due to arg
                # conversions into the JIT, using our new args stuff?
                if (len(sig[1]) != 0):
                    # We have arguments or our return-value boxing can fail
                    methodInfal = False
                else:
                    methodInfal = hasInfallibleImpl
                # For now, only bother to output args if we're side-effect-free.
                if self.member.affects == "Nothing":
                    args = sig[1]
                else:
                    args = None

            aliasSet = self.aliasSet()
            result = self.defineJitInfo(methodinfo, method, "Method",
                                        methodInfal, movable, aliasSet,
                                        False, False, "0",
                                        [s[0] for s in sigs], args)
            return result
        raise TypeError("Illegal member type to CGPropertyJITInfo")

    def mayBeMovable(self):
        """
        Returns whether this attribute or method may be movable, just
        based on Affects/DependsOn annotations.
        """
        affects = self.member.affects
        dependsOn = self.member.dependsOn
        assert affects in IDLInterfaceMember.AffectsValues
        assert dependsOn in IDLInterfaceMember.DependsOnValues
        # Things that are DependsOn=DeviceState are not movable, because we
        # don't want them coalesced with each other or loop-hoisted, since
        # their return value can change even if nothing is going on from our
        # point of view.
        return (affects == "Nothing" and
                (dependsOn != "Everything" and dependsOn != "DeviceState"))

    def aliasSet(self):
        """Returns the alias set to store in the jitinfo.  This may not be the
        effective alias set the JIT uses, depending on whether we have enough
        information about our args to allow the JIT to prove that effectful
        argument conversions won't happen.

        """
        dependsOn = self.member.dependsOn
        assert dependsOn in IDLInterfaceMember.DependsOnValues

        if dependsOn == "Nothing" or dependsOn == "DeviceState":
            assert self.member.affects == "Nothing"
            return "AliasNone"

        if dependsOn == "DOMState":
            assert self.member.affects == "Nothing"
            return "AliasDOMSets"

        return "AliasEverything"

    @staticmethod
    def getJSReturnTypeTag(t):
        if t.nullable():
            # Sometimes it might return null, sometimes not
            return "JSVAL_TYPE_UNKNOWN"
        if t.isVoid():
            # No return, every time
            return "JSVAL_TYPE_UNDEFINED"
        if t.isArray():
            # No idea yet
            assert False
        if t.isSequence():
            return "JSVAL_TYPE_OBJECT"
        if t.isMozMap():
            return "JSVAL_TYPE_OBJECT"
        if t.isGeckoInterface():
            return "JSVAL_TYPE_OBJECT"
        if t.isString():
            return "JSVAL_TYPE_STRING"
        if t.isEnum():
            return "JSVAL_TYPE_STRING"
        if t.isCallback():
            return "JSVAL_TYPE_OBJECT"
        if t.isAny():
            # The whole point is to return various stuff
            return "JSVAL_TYPE_UNKNOWN"
        if t.isObject():
            return "JSVAL_TYPE_OBJECT"
        if t.isSpiderMonkeyInterface():
            return "JSVAL_TYPE_OBJECT"
        if t.isUnion():
            u = t.unroll()
            if u.hasNullableType:
                # Might be null or not
                return "JSVAL_TYPE_UNKNOWN"
            return reduce(CGMemberJITInfo.getSingleReturnType,
                          u.flatMemberTypes, "")
        if t.isDictionary():
            return "JSVAL_TYPE_OBJECT"
        if t.isDate():
            return "JSVAL_TYPE_OBJECT"
        if not t.isPrimitive():
            raise TypeError("No idea what type " + str(t) + " is.")
        tag = t.tag()
        if tag == IDLType.Tags.bool:
            return "JSVAL_TYPE_BOOLEAN"
        if tag in [IDLType.Tags.int8, IDLType.Tags.uint8,
                   IDLType.Tags.int16, IDLType.Tags.uint16,
                   IDLType.Tags.int32]:
            return "JSVAL_TYPE_INT32"
        if tag in [IDLType.Tags.int64, IDLType.Tags.uint64,
                   IDLType.Tags.unrestricted_float, IDLType.Tags.float,
                   IDLType.Tags.unrestricted_double, IDLType.Tags.double]:
            # These all use JS_NumberValue, which can return int or double.
            # But TI treats "double" as meaning "int or double", so we're
            # good to return JSVAL_TYPE_DOUBLE here.
            return "JSVAL_TYPE_DOUBLE"
        if tag != IDLType.Tags.uint32:
            raise TypeError("No idea what type " + str(t) + " is.")
        # uint32 is sometimes int and sometimes double.
        return "JSVAL_TYPE_DOUBLE"

    @staticmethod
    def getSingleReturnType(existingType, t):
        type = CGMemberJITInfo.getJSReturnTypeTag(t)
        if existingType == "":
            # First element of the list; just return its type
            return type

        if type == existingType:
            return existingType
        if ((type == "JSVAL_TYPE_DOUBLE" and
             existingType == "JSVAL_TYPE_INT32") or
            (existingType == "JSVAL_TYPE_DOUBLE" and
             type == "JSVAL_TYPE_INT32")):
            # Promote INT32 to DOUBLE as needed
            return "JSVAL_TYPE_DOUBLE"
        # Different types
        return "JSVAL_TYPE_UNKNOWN"

    @staticmethod
    def getJSArgType(t):
        assert not t.isVoid()
        if t.nullable():
            # Sometimes it might return null, sometimes not
            return "JSJitInfo_ArgType::Null as i32 | %s" % CGMemberJITInfo.getJSArgType(t.inner)
        if t.isArray():
            # No idea yet
            assert False
        if t.isSequence():
            return "JSJitInfo_ArgType::Object as i32"
        if t.isGeckoInterface():
            return "JSJitInfo_ArgType::Object as i32"
        if t.isString():
            return "JSJitInfo_ArgType::String as i32"
        if t.isEnum():
            return "JSJitInfo_ArgType::String as i32"
        if t.isCallback():
            return "JSJitInfo_ArgType::Object as i32"
        if t.isAny():
            # The whole point is to return various stuff
            return "JSJitInfo_ArgType::Any as i32"
        if t.isObject():
            return "JSJitInfo_ArgType::Object as i32"
        if t.isSpiderMonkeyInterface():
            return "JSJitInfo_ArgType::Object as i32"
        if t.isUnion():
            u = t.unroll()
            type = "JSJitInfo::Null as i32" if u.hasNullableType else ""
            return reduce(CGMemberJITInfo.getSingleArgType,
                          u.flatMemberTypes, type)
        if t.isDictionary():
            return "JSJitInfo_ArgType::Object as i32"
        if t.isDate():
            return "JSJitInfo_ArgType::Object as i32"
        if not t.isPrimitive():
            raise TypeError("No idea what type " + str(t) + " is.")
        tag = t.tag()
        if tag == IDLType.Tags.bool:
            return "JSJitInfo_ArgType::Boolean as i32"
        if tag in [IDLType.Tags.int8, IDLType.Tags.uint8,
                   IDLType.Tags.int16, IDLType.Tags.uint16,
                   IDLType.Tags.int32]:
            return "JSJitInfo_ArgType::Integer as i32"
        if tag in [IDLType.Tags.int64, IDLType.Tags.uint64,
                   IDLType.Tags.unrestricted_float, IDLType.Tags.float,
                   IDLType.Tags.unrestricted_double, IDLType.Tags.double]:
            # These all use JS_NumberValue, which can return int or double.
            # But TI treats "double" as meaning "int or double", so we're
            # good to return JSVAL_TYPE_DOUBLE here.
            return "JSJitInfo_ArgType::Double as i32"
        if tag != IDLType.Tags.uint32:
            raise TypeError("No idea what type " + str(t) + " is.")
        # uint32 is sometimes int and sometimes double.
        return "JSJitInfo_ArgType::Double as i32"

    @staticmethod
    def getSingleArgType(existingType, t):
        type = CGMemberJITInfo.getJSArgType(t)
        if existingType == "":
            # First element of the list; just return its type
            return type

        if type == existingType:
            return existingType
        return "%s | %s" % (existingType, type)


def getEnumValueName(value):
    # Some enum values can be empty strings.  Others might have weird
    # characters in them.  Deal with the former by returning "_empty",
    # deal with possible name collisions from that by throwing if the
    # enum value is actually "_empty", and throw on any value
    # containing non-ASCII chars for now. Replace all chars other than
    # [0-9A-Za-z_] with '_'.
    if re.match("[^\x20-\x7E]", value):
        raise SyntaxError('Enum value "' + value + '" contains non-ASCII characters')
    if re.match("^[0-9]", value):
        raise SyntaxError('Enum value "' + value + '" starts with a digit')
    value = re.sub(r'[^0-9A-Za-z_]', '_', value)
    if re.match("^_[A-Z]|__", value):
        raise SyntaxError('Enum value "' + value + '" is reserved by the C++ spec')
    if value == "_empty":
        raise SyntaxError('"_empty" is not an IDL enum value we support yet')
    if value == "":
        return "_empty"
    return MakeNativeName(value)


class CGEnum(CGThing):
    def __init__(self, enum):
        CGThing.__init__(self)

        decl = """\
#[repr(usize)]
#[derive(JSTraceable, PartialEq, Copy, Clone, HeapSizeOf, Debug)]
pub enum %s {
    %s
}
""" % (enum.identifier.name, ",\n    ".join(map(getEnumValueName, enum.values())))

        inner = """\
use dom::bindings::conversions::ToJSValConvertible;
use js::jsapi::{JSContext, MutableHandleValue};
use js::jsval::JSVal;

pub const strings: &'static [&'static str] = &[
    %s,
];

impl ToJSValConvertible for super::%s {
    unsafe fn to_jsval(&self, cx: *mut JSContext, rval: MutableHandleValue) {
        strings[*self as usize].to_jsval(cx, rval);
    }
}
""" % (",\n    ".join(['"%s"' % val for val in enum.values()]), enum.identifier.name)

        self.cgRoot = CGList([
            CGGeneric(decl),
            CGNamespace.build([enum.identifier.name + "Values"],
                              CGIndenter(CGGeneric(inner)), public=True),
        ])

    def define(self):
        return self.cgRoot.define()


def convertConstIDLValueToRust(value):
    tag = value.type.tag()
    if tag in [IDLType.Tags.int8, IDLType.Tags.uint8,
               IDLType.Tags.int16, IDLType.Tags.uint16,
               IDLType.Tags.int32, IDLType.Tags.uint32,
               IDLType.Tags.int64, IDLType.Tags.uint64,
               IDLType.Tags.unrestricted_float, IDLType.Tags.float,
               IDLType.Tags.unrestricted_double, IDLType.Tags.double]:
        return str(value.value)

    if tag == IDLType.Tags.bool:
        return toStringBool(value.value)

    raise TypeError("Const value of unhandled type: " + value.type)


class CGConstant(CGThing):
    def __init__(self, constants):
        CGThing.__init__(self)
        self.constants = constants

    def define(self):
        def stringDecl(const):
            name = const.identifier.name
            value = convertConstIDLValueToRust(const.value)
            return CGGeneric("pub const %s: %s = %s;\n" % (name, builtinNames[const.value.type.tag()], value))

        return CGIndenter(CGList(stringDecl(m) for m in self.constants)).define()


def getUnionTypeTemplateVars(type, descriptorProvider):
    # For dictionaries and sequences we need to pass None as the failureCode
    # for getJSToNativeConversionInfo.
    # Also, for dictionaries we would need to handle conversion of
    # null/undefined to the dictionary correctly.
    if type.isDictionary():
        raise TypeError("Can't handle dictionaries in unions")

    if type.isGeckoInterface():
        name = type.inner.identifier.name
        typeName = descriptorProvider.getDescriptor(name).returnType
    elif type.isEnum():
        name = type.inner.identifier.name
        typeName = name
    elif type.isSequence():
        name = type.name
        inner = getUnionTypeTemplateVars(innerSequenceType(type), descriptorProvider)
        typeName = "Vec<" + inner["typeName"] + ">"
    elif type.isArray():
        name = str(type)
        # XXXjdm dunno about typeName here
        typeName = "/*" + type.name + "*/"
    elif type.isByteString():
        name = type.name
        typeName = "ByteString"
    elif type.isDOMString():
        name = type.name
        typeName = "DOMString"
    elif type.isUSVString():
        name = type.name
        typeName = "USVString"
    elif type.isPrimitive():
        name = type.name
        typeName = builtinNames[type.tag()]
    else:
        name = type.name
        typeName = "/*" + type.name + "*/"

    info = getJSToNativeConversionInfo(
        type, descriptorProvider, failureCode="return Ok(None);",
        exceptionCode='return Err(());',
        isDefinitelyObject=True)
    template = info.template

    assert not type.isObject()
    jsConversion = string.Template(template).substitute({
        "val": "value",
    })
    jsConversion = CGWrapper(CGGeneric(jsConversion), pre="Ok(Some(", post="))")

    return {
        "name": name,
        "typeName": typeName,
        "jsConversion": jsConversion,
    }


class CGUnionStruct(CGThing):
    def __init__(self, type, descriptorProvider):
        assert not type.nullable()
        assert not type.hasNullableType

        CGThing.__init__(self)
        self.type = type
        self.descriptorProvider = descriptorProvider

    def define(self):
        templateVars = map(lambda t: getUnionTypeTemplateVars(t, self.descriptorProvider),
                           self.type.flatMemberTypes)
        enumValues = [
            "    %s(%s)," % (v["name"], v["typeName"]) for v in templateVars
        ]
        enumConversions = [
            "            %s::%s(ref inner) => inner.to_jsval(cx, rval),"
            % (self.type, v["name"]) for v in templateVars
        ]
        return ("""\
pub enum %s {
%s
}

impl ToJSValConvertible for %s {
    unsafe fn to_jsval(&self, cx: *mut JSContext, rval: MutableHandleValue) {
        match *self {
%s
        }
    }
}
""") % (self.type, "\n".join(enumValues), self.type, "\n".join(enumConversions))


class CGUnionConversionStruct(CGThing):
    def __init__(self, type, descriptorProvider):
        assert not type.nullable()
        assert not type.hasNullableType

        CGThing.__init__(self)
        self.type = type
        self.descriptorProvider = descriptorProvider

    def from_jsval(self):
        memberTypes = self.type.flatMemberTypes
        names = []
        conversions = []

        def get_name(memberType):
            if self.type.isGeckoInterface():
                return memberType.inner.identifier.name

            return memberType.name

        def get_match(name):
            return (
                "match %s::TryConvertTo%s(cx, value) {\n"
                "    Err(_) => return Err(()),\n"
                "    Ok(Some(value)) => return Ok(%s::%s(value)),\n"
                "    Ok(None) => (),\n"
                "}\n") % (self.type, name, self.type, name)

        interfaceMemberTypes = filter(lambda t: t.isNonCallbackInterface(), memberTypes)
        if len(interfaceMemberTypes) > 0:
            typeNames = [get_name(memberType) for memberType in interfaceMemberTypes]
            interfaceObject = CGList(CGGeneric(get_match(typeName)) for typeName in typeNames)
            names.extend(typeNames)
        else:
            interfaceObject = None

        arrayObjectMemberTypes = filter(lambda t: t.isArray() or t.isSequence(), memberTypes)
        if len(arrayObjectMemberTypes) > 0:
            assert len(arrayObjectMemberTypes) == 1
            typeName = arrayObjectMemberTypes[0].name
            arrayObject = CGGeneric(get_match(typeName))
            names.append(typeName)
        else:
            arrayObject = None

        dateObjectMemberTypes = filter(lambda t: t.isDate(), memberTypes)
        if len(dateObjectMemberTypes) > 0:
            assert len(dateObjectMemberTypes) == 1
            raise TypeError("Can't handle dates in unions.")
        else:
            dateObject = None

        callbackMemberTypes = filter(lambda t: t.isCallback() or t.isCallbackInterface(), memberTypes)
        if len(callbackMemberTypes) > 0:
            assert len(callbackMemberTypes) == 1
            raise TypeError("Can't handle callbacks in unions.")
        else:
            callbackObject = None

        dictionaryMemberTypes = filter(lambda t: t.isDictionary(), memberTypes)
        if len(dictionaryMemberTypes) > 0:
            raise TypeError("No support for unwrapping dictionaries as member "
                            "of a union")
        else:
            dictionaryObject = None

        if callbackObject or dictionaryObject:
            assert False, "Not currently supported"
        else:
            nonPlatformObject = None

        objectMemberTypes = filter(lambda t: t.isObject(), memberTypes)
        if len(objectMemberTypes) > 0:
            raise TypeError("Can't handle objects in unions.")
        else:
            object = None

        hasObjectTypes = interfaceObject or arrayObject or dateObject or nonPlatformObject or object
        if hasObjectTypes:
            assert interfaceObject or arrayObject
            templateBody = CGList([], "\n")
            if interfaceObject:
                templateBody.append(interfaceObject)
            if arrayObject:
                templateBody.append(arrayObject)
            conversions.append(CGIfWrapper("value.get().is_object()", templateBody))
        stringTypes = [t for t in memberTypes if t.isString() or t.isEnum()]
        numericTypes = [t for t in memberTypes if t.isNumeric()]
        booleanTypes = [t for t in memberTypes if t.isBoolean()]
        if stringTypes or numericTypes or booleanTypes:
            assert len(stringTypes) <= 1
            assert len(numericTypes) <= 1
            assert len(booleanTypes) <= 1

            def getStringOrPrimitiveConversion(memberType):
                typename = get_name(memberType)
                return CGGeneric(get_match(typename))
            other = []
            stringConversion = map(getStringOrPrimitiveConversion, stringTypes)
            numericConversion = map(getStringOrPrimitiveConversion, numericTypes)
            booleanConversion = map(getStringOrPrimitiveConversion, booleanTypes)
            if stringConversion:
                if booleanConversion:
                    other.append(CGIfWrapper("value.get().is_boolean()", booleanConversion[0]))
                if numericConversion:
                    other.append(CGIfWrapper("value.get().is_number()", numericConversion[0]))
                other.append(stringConversion[0])
            elif numericConversion:
                if booleanConversion:
                    other.append(CGIfWrapper("value.get().is_boolean()", booleanConversion[0]))
                other.append(numericConversion[0])
            else:
                assert booleanConversion
                other.append(booleanConversion[0])
            conversions.append(CGList(other, "\n\n"))
        conversions.append(CGGeneric(
            "throw_not_in_union(cx, \"%s\");\n"
            "Err(())" % ", ".join(names)))
        method = CGWrapper(
            CGIndenter(CGList(conversions, "\n\n")),
            pre="unsafe fn from_jsval(cx: *mut JSContext,\n"
                "                     value: HandleValue, _option: ()) -> Result<%s, ()> {\n" % self.type,
            post="\n}")
        return CGWrapper(
            CGIndenter(CGList([
                CGGeneric("type Config = ();"),
                method,
            ], "\n")),
            pre="impl FromJSValConvertible for %s {\n" % self.type,
            post="\n}")

    def try_method(self, t):
        templateVars = getUnionTypeTemplateVars(t, self.descriptorProvider)
        returnType = "Result<Option<%s>, ()>" % templateVars["typeName"]
        jsConversion = templateVars["jsConversion"]

        return CGWrapper(
            CGIndenter(jsConversion, 4),
            pre="unsafe fn TryConvertTo%s(cx: *mut JSContext, value: HandleValue) -> %s {\n" % (t.name, returnType),
            post="\n}")

    def define(self):
        from_jsval = self.from_jsval()
        methods = CGIndenter(CGList([
            self.try_method(t) for t in self.type.flatMemberTypes
        ], "\n\n"))
        return """
%s

impl %s {
%s
}
""" % (from_jsval.define(), self.type, methods.define())


class ClassItem:
    """ Use with CGClass """
    def __init__(self, name, visibility):
        self.name = name
        self.visibility = visibility

    def declare(self, cgClass):
        assert False

    def define(self, cgClass):
        assert False


class ClassBase(ClassItem):
    def __init__(self, name, visibility='pub'):
        ClassItem.__init__(self, name, visibility)

    def declare(self, cgClass):
        return '%s %s' % (self.visibility, self.name)

    def define(self, cgClass):
        # Only in the header
        return ''


class ClassMethod(ClassItem):
    def __init__(self, name, returnType, args, inline=False, static=False,
                 virtual=False, const=False, bodyInHeader=False,
                 templateArgs=None, visibility='public', body=None,
                 breakAfterReturnDecl="\n",
                 breakAfterSelf="\n", override=False):
        """
        override indicates whether to flag the method as MOZ_OVERRIDE
        """
        assert not override or virtual
        assert not (override and static)
        self.returnType = returnType
        self.args = args
        self.inline = False
        self.static = static
        self.virtual = virtual
        self.const = const
        self.bodyInHeader = True
        self.templateArgs = templateArgs
        self.body = body
        self.breakAfterReturnDecl = breakAfterReturnDecl
        self.breakAfterSelf = breakAfterSelf
        self.override = override
        ClassItem.__init__(self, name, visibility)

    def getDecorators(self, declaring):
        decorators = []
        if self.inline:
            decorators.append('inline')
        if declaring:
            if self.static:
                decorators.append('static')
            if self.virtual:
                decorators.append('virtual')
        if decorators:
            return ' '.join(decorators) + ' '
        return ''

    def getBody(self):
        # Override me or pass a string to constructor
        assert self.body is not None
        return self.body

    def declare(self, cgClass):
        templateClause = '<%s>' % ', '.join(self.templateArgs) \
                         if self.bodyInHeader and self.templateArgs else ''
        args = ', '.join([a.declare() for a in self.args])
        if self.bodyInHeader:
            body = CGIndenter(CGGeneric(self.getBody())).define()
            body = ' {\n' + body + '\n}'
        else:
            body = ';'

        return string.Template(
            "${decorators}%s"
            "${visibility}fn ${name}${templateClause}(${args})${returnType}${const}${override}${body}%s" %
            (self.breakAfterReturnDecl, self.breakAfterSelf)
        ).substitute({
            'templateClause': templateClause,
            'decorators': self.getDecorators(True),
            'returnType': (" -> %s" % self.returnType) if self.returnType else "",
            'name': self.name,
            'const': ' const' if self.const else '',
            'override': ' MOZ_OVERRIDE' if self.override else '',
            'args': args,
            'body': body,
            'visibility': self.visibility + ' ' if self.visibility != 'priv' else ''
        })

    def define(self, cgClass):
        pass


class ClassConstructor(ClassItem):
    """
    Used for adding a constructor to a CGClass.

    args is a list of Argument objects that are the arguments taken by the
    constructor.

    inline should be True if the constructor should be marked inline.

    bodyInHeader should be True if the body should be placed in the class
    declaration in the header.

    visibility determines the visibility of the constructor (public,
    protected, private), defaults to private.

    explicit should be True if the constructor should be marked explicit.

    baseConstructors is a list of strings containing calls to base constructors,
    defaults to None.

    body contains a string with the code for the constructor, defaults to empty.
    """
    def __init__(self, args, inline=False, bodyInHeader=False,
                 visibility="priv", explicit=False, baseConstructors=None,
                 body=""):
        self.args = args
        self.inline = False
        self.bodyInHeader = bodyInHeader
        self.explicit = explicit
        self.baseConstructors = baseConstructors or []
        self.body = body
        ClassItem.__init__(self, None, visibility)

    def getDecorators(self, declaring):
        decorators = []
        if self.explicit:
            decorators.append('explicit')
        if self.inline and declaring:
            decorators.append('inline')
        if decorators:
            return ' '.join(decorators) + ' '
        return ''

    def getInitializationList(self, cgClass):
        items = [str(c) for c in self.baseConstructors]
        for m in cgClass.members:
            if not m.static:
                initialize = m.body
                if initialize:
                    items.append(m.name + "(" + initialize + ")")

        if len(items) > 0:
            return '\n  : ' + ',\n    '.join(items)
        return ''

    def getBody(self, cgClass):
        initializers = ["    parent: %s" % str(self.baseConstructors[0])]
        return (self.body + (
                "let mut ret = Rc::new(%s {\n"
                "%s\n"
                "});\n"
                "// Note: callback cannot be moved after calling init.\n"
                "match Rc::get_mut(&mut ret) {\n"
                "    Some(ref mut callback) => callback.parent.init(%s),\n"
                "    None => unreachable!(),\n"
                "};\n"
                "ret") % (cgClass.name, '\n'.join(initializers), self.args[0].name))

    def declare(self, cgClass):
        args = ', '.join([a.declare() for a in self.args])
        body = '    ' + self.getBody(cgClass)
        body = stripTrailingWhitespace(body.replace('\n', '\n    '))
        if len(body) > 0:
            body += '\n'
        body = ' {\n' + body + '}'

        return string.Template("""\
pub fn ${decorators}new(${args}) -> Rc<${className}>${body}
""").substitute({'decorators': self.getDecorators(True),
                 'className': cgClass.getNameString(),
                 'args': args,
                 'body': body})

    def define(self, cgClass):
        if self.bodyInHeader:
            return ''

        args = ', '.join([a.define() for a in self.args])

        body = '    ' + self.getBody()
        body = '\n' + stripTrailingWhitespace(body.replace('\n', '\n    '))
        if len(body) > 0:
            body += '\n'

        return string.Template("""\
${decorators}
${className}::${className}(${args})${initializationList}
{${body}}
""").substitute({'decorators': self.getDecorators(False),
                 'className': cgClass.getNameString(),
                 'args': args,
                 'initializationList': self.getInitializationList(cgClass),
                 'body': body})


class ClassMember(ClassItem):
    def __init__(self, name, type, visibility="priv", static=False,
                 body=None):
        self.type = type
        self.static = static
        self.body = body
        ClassItem.__init__(self, name, visibility)

    def declare(self, cgClass):
        return '%s %s: %s,\n' % (self.visibility, self.name, self.type)

    def define(self, cgClass):
        if not self.static:
            return ''
        if self.body:
            body = " = " + self.body
        else:
            body = ""
        return '%s %s::%s%s;\n' % (self.type, cgClass.getNameString(),
                                   self.name, body)


class CGClass(CGThing):
    def __init__(self, name, bases=[], members=[], constructors=[],
                 destructor=None, methods=[],
                 typedefs=[], enums=[], unions=[], templateArgs=[],
                 templateSpecialization=[],
                 disallowCopyConstruction=False, indent='',
                 decorators='',
                 extradeclarations=''):
        CGThing.__init__(self)
        self.name = name
        self.bases = bases
        self.members = members
        self.constructors = constructors
        # We store our single destructor in a list, since all of our
        # code wants lists of members.
        self.destructors = [destructor] if destructor else []
        self.methods = methods
        self.typedefs = typedefs
        self.enums = enums
        self.unions = unions
        self.templateArgs = templateArgs
        self.templateSpecialization = templateSpecialization
        self.disallowCopyConstruction = disallowCopyConstruction
        self.indent = indent
        self.decorators = decorators
        self.extradeclarations = extradeclarations

    def getNameString(self):
        className = self.name
        if self.templateSpecialization:
            className = className + \
                '<%s>' % ', '.join([str(a) for a
                                    in self.templateSpecialization])
        return className

    def define(self):
        result = ''
        if self.templateArgs:
            templateArgs = [a.declare() for a in self.templateArgs]
            templateArgs = templateArgs[len(self.templateSpecialization):]
            result = result + self.indent + 'template <%s>\n' % ','.join([str(a) for a in templateArgs])

        if self.templateSpecialization:
            specialization = \
                '<%s>' % ', '.join([str(a) for a in self.templateSpecialization])
        else:
            specialization = ''

        myself = ''
        if self.decorators != '':
            myself += self.decorators + '\n'
        myself += '%spub struct %s%s' % (self.indent, self.name, specialization)
        result += myself

        assert len(self.bases) == 1  # XXjdm Can we support multiple inheritance?

        result += ' {\n'

        if self.bases:
            self.members = [ClassMember("parent", self.bases[0].name, "pub")] + self.members

        result += CGIndenter(CGGeneric(self.extradeclarations),
                             len(self.indent)).define()

        def declareMembers(cgClass, memberList):
            result = ''

            for member in memberList:
                declaration = member.declare(cgClass)
                declaration = CGIndenter(CGGeneric(declaration)).define()
                result = result + declaration
            return result

        if self.disallowCopyConstruction:
            class DisallowedCopyConstructor(object):
                def __init__(self):
                    self.visibility = "private"

                def declare(self, cgClass):
                    name = cgClass.getNameString()
                    return ("%s(const %s&) MOZ_DELETE;\n"
                            "void operator=(const %s) MOZ_DELETE;\n" % (name, name, name))
            disallowedCopyConstructors = [DisallowedCopyConstructor()]
        else:
            disallowedCopyConstructors = []

        order = [(self.enums, ''), (self.unions, ''),
                 (self.typedefs, ''), (self.members, '')]

        for (memberList, separator) in order:
            memberString = declareMembers(self, memberList)
            if self.indent:
                memberString = CGIndenter(CGGeneric(memberString),
                                          len(self.indent)).define()
            result = result + memberString

        result += self.indent + '}\n\n'
        result += 'impl %s {\n' % self.name

        order = [(self.constructors + disallowedCopyConstructors, '\n'),
                 (self.destructors, '\n'), (self.methods, '\n)')]
        for (memberList, separator) in order:
            memberString = declareMembers(self, memberList)
            if self.indent:
                memberString = CGIndenter(CGGeneric(memberString),
                                          len(self.indent)).define()
            result = result + memberString

        result += "}"
        return result


class CGProxySpecialOperation(CGPerSignatureCall):
    """
    Base class for classes for calling an indexed or named special operation
    (don't use this directly, use the derived classes below).
    """
    def __init__(self, descriptor, operation):
        nativeName = MakeNativeName(descriptor.binaryNameFor(operation))
        operation = descriptor.operations[operation]
        assert len(operation.signatures()) == 1
        signature = operation.signatures()[0]

        (returnType, arguments) = signature

        # We pass len(arguments) as the final argument so that the
        # CGPerSignatureCall won't do any argument conversion of its own.
        CGPerSignatureCall.__init__(self, returnType, "", arguments, nativeName,
                                    False, descriptor, operation,
                                    len(arguments))

        if operation.isSetter() or operation.isCreator():
            # arguments[0] is the index or name of the item that we're setting.
            argument = arguments[1]
            info = getJSToNativeConversionInfo(
                argument.type, descriptor, treatNullAs=argument.treatNullAs,
                exceptionCode="return false;")
            template = info.template
            declType = info.declType

            templateValues = {
                "val": "value.handle()",
            }
            self.cgRoot.prepend(instantiateJSToNativeConversionTemplate(
                template, templateValues, declType, argument.identifier.name))
            self.cgRoot.prepend(CGGeneric("rooted!(in(cx) let value = desc.value);"))
        elif operation.isGetter():
            self.cgRoot.prepend(CGGeneric("let mut found = false;"))

    def getArguments(self):
        def process(arg):
            argVal = arg.identifier.name
            if arg.type.isGeckoInterface() and not arg.type.unroll().inner.isCallback():
                argVal += ".r()"
            return argVal
        args = [(a, process(a)) for a in self.arguments]
        if self.idlNode.isGetter():
            args.append((FakeArgument(BuiltinTypes[IDLBuiltinType.Types.boolean],
                                      self.idlNode),
                         "&mut found"))
        return args

    def wrap_return_value(self):
        if not self.idlNode.isGetter() or self.templateValues is None:
            return ""

        wrap = CGGeneric(wrapForType(**self.templateValues))
        wrap = CGIfWrapper("found", wrap)
        return "\n" + wrap.define()


class CGProxyIndexedGetter(CGProxySpecialOperation):
    """
    Class to generate a call to an indexed getter. If templateValues is not None
    the returned value will be wrapped with wrapForType using templateValues.
    """
    def __init__(self, descriptor, templateValues=None):
        self.templateValues = templateValues
        CGProxySpecialOperation.__init__(self, descriptor, 'IndexedGetter')


class CGProxyIndexedSetter(CGProxySpecialOperation):
    """
    Class to generate a call to an indexed setter.
    """
    def __init__(self, descriptor):
        CGProxySpecialOperation.__init__(self, descriptor, 'IndexedSetter')


class CGProxyNamedOperation(CGProxySpecialOperation):
    """
    Class to generate a call to a named operation.
    """
    def __init__(self, descriptor, name):
        CGProxySpecialOperation.__init__(self, descriptor, name)

    def define(self):
        # Our first argument is the id we're getting.
        argName = self.arguments[0].identifier.name
        return ("let %s = jsid_to_str(cx, id);\n"
                "let this = UnwrapProxy(proxy);\n"
                "let this = &*this;\n" % argName +
                CGProxySpecialOperation.define(self))


class CGProxyNamedGetter(CGProxyNamedOperation):
    """
    Class to generate a call to an named getter. If templateValues is not None
    the returned value will be wrapped with wrapForType using templateValues.
    """
    def __init__(self, descriptor, templateValues=None):
        self.templateValues = templateValues
        CGProxySpecialOperation.__init__(self, descriptor, 'NamedGetter')


class CGProxyNamedPresenceChecker(CGProxyNamedGetter):
    """
    Class to generate a call that checks whether a named property exists.
    For now, we just delegate to CGProxyNamedGetter
    """
    def __init__(self, descriptor):
        CGProxyNamedGetter.__init__(self, descriptor)


class CGProxyNamedSetter(CGProxyNamedOperation):
    """
    Class to generate a call to a named setter.
    """
    def __init__(self, descriptor):
        CGProxySpecialOperation.__init__(self, descriptor, 'NamedSetter')


class CGProxyNamedDeleter(CGProxyNamedOperation):
    """
    Class to generate a call to a named deleter.
    """
    def __init__(self, descriptor):
        CGProxySpecialOperation.__init__(self, descriptor, 'NamedDeleter')


class CGProxyUnwrap(CGAbstractMethod):
    def __init__(self, descriptor):
        args = [Argument('HandleObject', 'obj')]
        CGAbstractMethod.__init__(self, descriptor, "UnwrapProxy",
                                  '*const ' + descriptor.concreteType, args,
                                  alwaysInline=True, unsafe=True)

    def definition_body(self):
        return CGGeneric("""\
/*if (xpc::WrapperFactory::IsXrayWrapper(obj)) {
    obj = js::UnwrapObject(obj);
}*/
//MOZ_ASSERT(IsProxy(obj));
let box_ = GetProxyPrivate(obj.get()).to_private() as *const %s;
return box_;""" % self.descriptor.concreteType)


class CGDOMJSProxyHandler_getOwnPropertyDescriptor(CGAbstractExternMethod):
    def __init__(self, descriptor):
        args = [Argument('*mut JSContext', 'cx'), Argument('HandleObject', 'proxy'),
                Argument('HandleId', 'id'),
                Argument('MutableHandle<PropertyDescriptor>', 'desc', mutable=True)]
        CGAbstractExternMethod.__init__(self, descriptor, "getOwnPropertyDescriptor",
                                        "bool", args)
        self.descriptor = descriptor

    def getBody(self):
        indexedGetter = self.descriptor.operations['IndexedGetter']
        indexedSetter = self.descriptor.operations['IndexedSetter']

        get = ""
        if indexedGetter or indexedSetter:
            get = "let index = get_array_index_from_id(cx, id);\n"

        if indexedGetter:
            attrs = "JSPROP_ENUMERATE"
            if self.descriptor.operations['IndexedSetter'] is None:
                attrs += " | JSPROP_READONLY"
            # FIXME(#11868) Should assign to desc.value, desc.get() is a copy.
            fillDescriptor = ("desc.get().value = result_root.get();\n"
                              "fill_property_descriptor(&mut desc, proxy.get(), %s);\n"
                              "return true;" % attrs)
            templateValues = {
                'jsvalRef': 'result_root.handle_mut()',
                'successCode': fillDescriptor,
                'pre': 'rooted!(in(cx) let mut result_root = UndefinedValue());'
            }
            get += ("if let Some(index) = index {\n" +
                    "    let this = UnwrapProxy(proxy);\n" +
                    "    let this = &*this;\n" +
                    CGIndenter(CGProxyIndexedGetter(self.descriptor, templateValues)).define() + "\n" +
                    "}\n")

        namedGetter = self.descriptor.operations['NamedGetter']
        if namedGetter:
            attrs = []
            if not self.descriptor.interface.getExtendedAttribute("LegacyUnenumerableNamedProperties"):
                attrs.append("JSPROP_ENUMERATE")
            if self.descriptor.operations['NamedSetter'] is None:
                attrs.append("JSPROP_READONLY")
            if attrs:
                attrs = " | ".join(attrs)
            else:
                attrs = "0"
            # FIXME(#11868) Should assign to desc.value, desc.get() is a copy.
            fillDescriptor = ("desc.get().value = result_root.get();\n"
                              "fill_property_descriptor(&mut desc, proxy.get(), %s);\n"
                              "return true;" % attrs)
            templateValues = {
                'jsvalRef': 'result_root.handle_mut()',
                'successCode': fillDescriptor,
                'pre': 'rooted!(in(cx) let mut result_root = UndefinedValue());'
            }
            # Once we start supporting OverrideBuiltins we need to make
            # ResolveOwnProperty or EnumerateOwnProperties filter out named
            # properties that shadow prototype properties.
            namedGet = ("\n" +
                        "if RUST_JSID_IS_STRING(id) && !has_property_on_prototype(cx, proxy, id) {\n" +
                        CGIndenter(CGProxyNamedGetter(self.descriptor, templateValues)).define() + "\n" +
                        "}\n")
        else:
            namedGet = ""

        # FIXME(#11868) Should assign to desc.obj, desc.get() is a copy.
        return get + """\
rooted!(in(cx) let expando = get_expando_object(proxy));
//if (!xpc::WrapperFactory::IsXrayWrapper(proxy) && (expando = GetExpandoObject(proxy))) {
if !expando.is_null() {
    if !JS_GetPropertyDescriptorById(cx, expando.handle(), id, desc) {
        return false;
    }
    if !desc.obj.is_null() {
        // Pretend the property lives on the wrapper.
        desc.get().obj = proxy.get();
        return true;
    }
}
""" + namedGet + """\
desc.get().obj = ptr::null_mut();
return true;"""

    def definition_body(self):
        return CGGeneric(self.getBody())


# TODO(Issue 5876)
class CGDOMJSProxyHandler_defineProperty(CGAbstractExternMethod):
    def __init__(self, descriptor):
        args = [Argument('*mut JSContext', 'cx'), Argument('HandleObject', 'proxy'),
                Argument('HandleId', 'id'),
                Argument('Handle<PropertyDescriptor>', 'desc'),
                Argument('*mut ObjectOpResult', 'opresult')]
        CGAbstractExternMethod.__init__(self, descriptor, "defineProperty", "bool", args)
        self.descriptor = descriptor

    def getBody(self):
        set = ""

        indexedSetter = self.descriptor.operations['IndexedSetter']
        if indexedSetter:
            set += ("let index = get_array_index_from_id(cx, id);\n" +
                    "if let Some(index) = index {\n" +
                    "    let this = UnwrapProxy(proxy);\n" +
                    "    let this = &*this;\n" +
                    CGIndenter(CGProxyIndexedSetter(self.descriptor)).define() +
                    "    return true;\n" +
                    "}\n")
        elif self.descriptor.operations['IndexedGetter']:
            set += ("if get_array_index_from_id(cx, id).is_some() {\n" +
                    "    return false;\n" +
                    "    //return ThrowErrorMessage(cx, MSG_NO_PROPERTY_SETTER, \"%s\");\n" +
                    "}\n") % self.descriptor.name

        namedSetter = self.descriptor.operations['NamedSetter']
        if namedSetter:
            if self.descriptor.hasUnforgeableMembers:
                raise TypeError("Can't handle a named setter on an interface that has "
                                "unforgeables. Figure out how that should work!")
            set += ("if RUST_JSID_IS_STRING(id) {\n" +
                    CGIndenter(CGProxyNamedSetter(self.descriptor)).define() +
                    "    return (*opresult).succeed();\n" +
                    "} else {\n" +
                    "    return false;\n" +
                    "}\n")
        else:
            set += ("if RUST_JSID_IS_STRING(id) {\n" +
                    CGIndenter(CGProxyNamedGetter(self.descriptor)).define() +
                    "    if (found) {\n"
                    # TODO(Issue 5876)
                    "        //return js::IsInNonStrictPropertySet(cx)\n" +
                    "        //       ? opresult.succeed()\n" +
                    "        //       : ThrowErrorMessage(cx, MSG_NO_NAMED_SETTER, \"${name}\");\n" +
                    "        return (*opresult).succeed();\n" +
                    "    }\n" +
                    "    return (*opresult).succeed();\n"
                    "}\n") % (self.descriptor.name, self.descriptor.name)
            set += "return proxyhandler::define_property(%s);" % ", ".join(a.name for a in self.args)
        return set

    def definition_body(self):
        return CGGeneric(self.getBody())


class CGDOMJSProxyHandler_delete(CGAbstractExternMethod):
    def __init__(self, descriptor):
        args = [Argument('*mut JSContext', 'cx'), Argument('HandleObject', 'proxy'),
                Argument('HandleId', 'id'),
                Argument('*mut ObjectOpResult', 'res')]
        CGAbstractExternMethod.__init__(self, descriptor, "delete", "bool", args)
        self.descriptor = descriptor

    def getBody(self):
        set = ""
        if self.descriptor.operations['NamedDeleter']:
            if self.descriptor.hasUnforgeableMembers:
                raise TypeError("Can't handle a deleter on an interface that has "
                                "unforgeables. Figure out how that should work!")
            set += CGProxyNamedDeleter(self.descriptor).define()
        set += "return proxyhandler::delete(%s);" % ", ".join(a.name for a in self.args)
        return set

    def definition_body(self):
        return CGGeneric(self.getBody())


class CGDOMJSProxyHandler_ownPropertyKeys(CGAbstractExternMethod):
    def __init__(self, descriptor):
        args = [Argument('*mut JSContext', 'cx'),
                Argument('HandleObject', 'proxy'),
                Argument('*mut AutoIdVector', 'props')]
        CGAbstractExternMethod.__init__(self, descriptor, "own_property_keys", "bool", args)
        self.descriptor = descriptor

    def getBody(self):
        body = dedent(
            """
            let unwrapped_proxy = UnwrapProxy(proxy);
            """)

        if self.descriptor.operations['IndexedGetter']:
            body += dedent(
                """
                for i in 0..(*unwrapped_proxy).Length() {
                    rooted!(in(cx) let rooted_jsid = int_to_jsid(i as i32));
                    AppendToAutoIdVector(props, rooted_jsid.handle().get());
                }
                """)

        if self.descriptor.operations['NamedGetter']:
            body += dedent(
                """
                for name in (*unwrapped_proxy).SupportedPropertyNames() {
                    let cstring = CString::new(name).unwrap();
                    let jsstring = JS_AtomizeAndPinString(cx, cstring.as_ptr());
                    rooted!(in(cx) let rooted = jsstring);
                    let jsid = INTERNED_STRING_TO_JSID(cx, rooted.handle().get());
                    rooted!(in(cx) let rooted_jsid = jsid);
                    AppendToAutoIdVector(props, rooted_jsid.handle().get());
                }
                """)

        body += dedent(
            """
            let expando = get_expando_object(proxy);
            if !expando.is_null() {
                rooted!(in(cx) let rooted_expando = expando);
                GetPropertyKeys(cx, rooted_expando.handle(), JSITER_OWNONLY | JSITER_HIDDEN | JSITER_SYMBOLS, props);
            }

            return true;
            """)

        return body

    def definition_body(self):
        return CGGeneric(self.getBody())


class CGDOMJSProxyHandler_getOwnEnumerablePropertyKeys(CGAbstractExternMethod):
    def __init__(self, descriptor):
        assert (descriptor.operations["IndexedGetter"] and
                descriptor.interface.getExtendedAttribute("LegacyUnenumerableNamedProperties"))
        args = [Argument('*mut JSContext', 'cx'),
                Argument('HandleObject', 'proxy'),
                Argument('*mut AutoIdVector', 'props')]
        CGAbstractExternMethod.__init__(self, descriptor,
                                        "getOwnEnumerablePropertyKeys", "bool", args)
        self.descriptor = descriptor

    def getBody(self):
        body = dedent(
            """
            let unwrapped_proxy = UnwrapProxy(proxy);
            """)

        if self.descriptor.operations['IndexedGetter']:
            body += dedent(
                """
                for i in 0..(*unwrapped_proxy).Length() {
                    rooted!(in(cx) let rooted_jsid = int_to_jsid(i as i32));
                    AppendToAutoIdVector(props, rooted_jsid.handle().get());
                }
                """)

        body += dedent(
            """
            let expando = get_expando_object(proxy);
            if !expando.is_null() {
                rooted!(in(cx) let rooted_expando = expando);
                GetPropertyKeys(cx, rooted_expando.handle(), JSITER_OWNONLY | JSITER_HIDDEN | JSITER_SYMBOLS, props);
            }

            return true;
            """)

        return body

    def definition_body(self):
        return CGGeneric(self.getBody())


class CGDOMJSProxyHandler_hasOwn(CGAbstractExternMethod):
    def __init__(self, descriptor):
        args = [Argument('*mut JSContext', 'cx'), Argument('HandleObject', 'proxy'),
                Argument('HandleId', 'id'), Argument('*mut bool', 'bp')]
        CGAbstractExternMethod.__init__(self, descriptor, "hasOwn", "bool", args)
        self.descriptor = descriptor

    def getBody(self):
        indexedGetter = self.descriptor.operations['IndexedGetter']
        if indexedGetter:
            indexed = ("let index = get_array_index_from_id(cx, id);\n" +
                       "if let Some(index) = index {\n" +
                       "    let this = UnwrapProxy(proxy);\n" +
                       "    let this = &*this;\n" +
                       CGIndenter(CGProxyIndexedGetter(self.descriptor)).define() + "\n" +
                       "    *bp = found;\n" +
                       "    return true;\n" +
                       "}\n\n")
        else:
            indexed = ""

        namedGetter = self.descriptor.operations['NamedGetter']
        if namedGetter:
            named = ("if RUST_JSID_IS_STRING(id) && !has_property_on_prototype(cx, proxy, id) {\n" +
                     CGIndenter(CGProxyNamedGetter(self.descriptor)).define() + "\n" +
                     "    *bp = found;\n"
                     "    return true;\n"
                     "}\n" +
                     "\n")
        else:
            named = ""

        return indexed + """\
rooted!(in(cx) let expando = get_expando_object(proxy));
if !expando.is_null() {
    let ok = JS_HasPropertyById(cx, expando.handle(), id, bp);
    if !ok || *bp {
        return ok;
    }
}
""" + named + """\
*bp = false;
return true;"""

    def definition_body(self):
        return CGGeneric(self.getBody())


class CGDOMJSProxyHandler_get(CGAbstractExternMethod):
    def __init__(self, descriptor):
        args = [Argument('*mut JSContext', 'cx'), Argument('HandleObject', 'proxy'),
                Argument('HandleValue', 'receiver'), Argument('HandleId', 'id'),
                Argument('MutableHandleValue', 'vp')]
        CGAbstractExternMethod.__init__(self, descriptor, "get", "bool", args)
        self.descriptor = descriptor

    def getBody(self):
        getFromExpando = """\
rooted!(in(cx) let expando = get_expando_object(proxy));
if !expando.is_null() {
    let mut hasProp = false;
    if !JS_HasPropertyById(cx, expando.handle(), id, &mut hasProp) {
        return false;
    }

    if hasProp {
        return JS_ForwardGetPropertyTo(cx, expando.handle(), id, receiver, vp);
    }
}"""

        templateValues = {
            'jsvalRef': 'vp',
            'successCode': 'return true;',
        }

        indexedGetter = self.descriptor.operations['IndexedGetter']
        if indexedGetter:
            getIndexedOrExpando = ("let index = get_array_index_from_id(cx, id);\n" +
                                   "if let Some(index) = index {\n" +
                                   "    let this = UnwrapProxy(proxy);\n" +
                                   "    let this = &*this;\n" +
                                   CGIndenter(CGProxyIndexedGetter(self.descriptor, templateValues)).define())
            getIndexedOrExpando += """\
    // Even if we don't have this index, we don't forward the
    // get on to our expando object.
} else {
    %s
}
""" % (stripTrailingWhitespace(getFromExpando.replace('\n', '\n    ')))
        else:
            getIndexedOrExpando = getFromExpando + "\n"

        namedGetter = self.descriptor.operations['NamedGetter']
        if namedGetter:
            getNamed = ("if RUST_JSID_IS_STRING(id) {\n" +
                        CGIndenter(CGProxyNamedGetter(self.descriptor, templateValues)).define() +
                        "}\n")
        else:
            getNamed = ""

        return """\
//MOZ_ASSERT(!xpc::WrapperFactory::IsXrayWrapper(proxy),
//"Should not have a XrayWrapper here");

%s
let mut found = false;
if !get_property_on_prototype(cx, proxy, id, &mut found, vp) {
    return false;
}

if found {
    return true;
}
%s
vp.set(UndefinedValue());
return true;""" % (getIndexedOrExpando, getNamed)

    def definition_body(self):
        return CGGeneric(self.getBody())


class CGDOMJSProxyHandler_className(CGAbstractExternMethod):
    def __init__(self, descriptor):
        args = [Argument('*mut JSContext', 'cx'), Argument('HandleObject', '_proxy')]
        CGAbstractExternMethod.__init__(self, descriptor, "className", "*const i8", args, doesNotPanic=True)
        self.descriptor = descriptor

    def getBody(self):
        return '%s as *const u8 as *const i8' % str_to_const_array(self.descriptor.name)

    def definition_body(self):
        return CGGeneric(self.getBody())


class CGAbstractClassHook(CGAbstractExternMethod):
    """
    Meant for implementing JSClass hooks, like Finalize or Trace. Does very raw
    'this' unwrapping as it assumes that the unwrapped type is always known.
    """
    def __init__(self, descriptor, name, returnType, args, doesNotPanic=False):
        CGAbstractExternMethod.__init__(self, descriptor, name, returnType,
                                        args)

    def definition_body_prologue(self):
        return CGGeneric("""
let this = native_from_object::<%s>(obj).unwrap();
""" % self.descriptor.concreteType)

    def definition_body(self):
        return CGList([
            self.definition_body_prologue(),
            self.generate_code(),
        ])

    def generate_code(self):
        raise NotImplementedError  # Override me!


def finalizeHook(descriptor, hookName, context):
    release = ""
    if descriptor.isGlobal():
        release += """\
finalize_global(obj);
"""
    elif descriptor.weakReferenceable:
        release += """\
let weak_box_ptr = JS_GetReservedSlot(obj, DOM_WEAK_SLOT).to_private() as *mut WeakBox<%s>;
if !weak_box_ptr.is_null() {
    let count = {
        let weak_box = &*weak_box_ptr;
        assert!(weak_box.value.get().is_some());
        assert!(weak_box.count.get() > 0);
        weak_box.value.set(None);
        let count = weak_box.count.get() - 1;
        weak_box.count.set(count);
        count
    };
    if count == 0 {
        mem::drop(Box::from_raw(weak_box_ptr));
    }
}
""" % descriptor.concreteType
    release += """\
if !this.is_null() {
    // The pointer can be null if the object is the unforgeable holder of that interface.
    let _ = Box::from_raw(this as *mut %s);
}
debug!("%s finalize: {:p}", this);\
""" % (descriptor.concreteType, descriptor.concreteType)
    return release


class CGClassTraceHook(CGAbstractClassHook):
    """
    A hook to trace through our native object; used for GC and CC
    """
    def __init__(self, descriptor):
        args = [Argument('*mut JSTracer', 'trc'), Argument('*mut JSObject', 'obj')]
        CGAbstractClassHook.__init__(self, descriptor, TRACE_HOOK_NAME, 'void',
                                     args, doesNotPanic=True)
        self.traceGlobal = descriptor.isGlobal()

    def generate_code(self):
        body = [CGGeneric("if this.is_null() { return; } // GC during obj creation\n"
                          "(*this).trace(%s);" % self.args[0].name)]
        if self.traceGlobal:
            body += [CGGeneric("trace_global(trc, obj);")]
        return CGList(body, "\n")


class CGClassConstructHook(CGAbstractExternMethod):
    """
    JS-visible constructor for our objects
    """
    def __init__(self, descriptor, constructor=None):
        args = [Argument('*mut JSContext', 'cx'), Argument('u32', 'argc'), Argument('*mut JSVal', 'vp')]
        name = CONSTRUCT_HOOK_NAME
        if constructor:
            name += "_" + constructor.identifier.name
        else:
            constructor = descriptor.interface.ctor()
            assert constructor
        CGAbstractExternMethod.__init__(self, descriptor, name, 'bool', args)
        self.constructor = constructor

    def definition_body(self):
        preamble = CGGeneric("""\
let global = global_root_from_object(JS_CALLEE(cx, vp).to_object());
let args = CallArgs::from_vp(vp, argc);
""")
        name = self.constructor.identifier.name
        nativeName = MakeNativeName(self.descriptor.binaryNameFor(name))
        callGenerator = CGMethodCall(["global.r()"], nativeName, True,
                                     self.descriptor, self.constructor)
        return CGList([preamble, callGenerator])


class CGClassFinalizeHook(CGAbstractClassHook):
    """
    A hook for finalize, used to release our native object.
    """
    def __init__(self, descriptor):
        args = [Argument('*mut FreeOp', '_fop'), Argument('*mut JSObject', 'obj')]
        CGAbstractClassHook.__init__(self, descriptor, FINALIZE_HOOK_NAME,
                                     'void', args)

    def generate_code(self):
        return CGGeneric(finalizeHook(self.descriptor, self.name, self.args[0].name))


class CGDOMJSProxyHandlerDOMClass(CGThing):
    def __init__(self, descriptor):
        CGThing.__init__(self)
        self.descriptor = descriptor

    def define(self):
        return "static Class: DOMClass = " + DOMClass(self.descriptor) + ";\n"


class CGInterfaceTrait(CGThing):
    def __init__(self, descriptor):
        CGThing.__init__(self)

        def attribute_arguments(needCx, argument=None):
            if needCx:
                yield "cx", "*mut JSContext"

            if argument:
                yield "value", argument_type(descriptor, argument)

        def members():
            for m in descriptor.interface.members:
                if (m.isMethod() and not m.isStatic() and
                        (not m.isIdentifierLess() or m.isStringifier())):
                    name = CGSpecializedMethod.makeNativeName(descriptor, m)
                    infallible = 'infallible' in descriptor.getExtendedAttributes(m)
                    for idx, (rettype, arguments) in enumerate(m.signatures()):
                        arguments = method_arguments(descriptor, rettype, arguments)
                        rettype = return_type(descriptor, rettype, infallible)
                        yield name + ('_' * idx), arguments, rettype
                elif m.isAttr() and not m.isStatic():
                    name = CGSpecializedGetter.makeNativeName(descriptor, m)
                    infallible = 'infallible' in descriptor.getExtendedAttributes(m, getter=True)
                    yield (name,
                           attribute_arguments(typeNeedsCx(m.type, True)),
                           return_type(descriptor, m.type, infallible))

                    if not m.readonly:
                        name = CGSpecializedSetter.makeNativeName(descriptor, m)
                        infallible = 'infallible' in descriptor.getExtendedAttributes(m, setter=True)
                        if infallible:
                            rettype = "()"
                        else:
                            rettype = "ErrorResult"
                        yield name, attribute_arguments(typeNeedsCx(m.type, False), m.type), rettype

            if descriptor.proxy:
                for name, operation in descriptor.operations.iteritems():
                    if not operation or operation.isStringifier():
                        continue

                    assert len(operation.signatures()) == 1
                    rettype, arguments = operation.signatures()[0]

                    infallible = 'infallible' in descriptor.getExtendedAttributes(operation)
                    if operation.isGetter():
                        arguments = method_arguments(descriptor, rettype, arguments, trailing=("found", "&mut bool"))

                        # If this interface 'supports named properties', then we
                        # should be able to access 'supported property names'
                        #
                        # WebIDL, Second Draft, section 3.2.4.5
                        # https://heycam.github.io/webidl/#idl-named-properties
                        if operation.isNamed():
                            yield "SupportedPropertyNames", [], "Vec<DOMString>"
                    else:
                        arguments = method_arguments(descriptor, rettype, arguments)
                    rettype = return_type(descriptor, rettype, infallible)
                    yield name, arguments, rettype

        def fmt(arguments):
            return "".join(", %s: %s" % argument for argument in arguments)

        methods = [
            CGGeneric("fn %s(&self%s) -> %s;\n" % (name, fmt(arguments), rettype))
            for name, arguments, rettype in members()
        ]
        if methods:
            self.cgRoot = CGWrapper(CGIndenter(CGList(methods, "")),
                                    pre="pub trait %sMethods {\n" % descriptor.interface.identifier.name,
                                    post="}")
        else:
            self.cgRoot = CGGeneric("")

    def define(self):
        return self.cgRoot.define()


class CGWeakReferenceableTrait(CGThing):
    def __init__(self, descriptor):
        CGThing.__init__(self)
        assert descriptor.weakReferenceable
        self.code = "impl WeakReferenceable for %s {}" % descriptor.interface.identifier.name

    def define(self):
        return self.code


class CGDescriptor(CGThing):
    def __init__(self, descriptor):
        CGThing.__init__(self)

        assert not descriptor.concrete or not descriptor.interface.isCallback()

        cgThings = []
        if not descriptor.interface.isCallback():
            cgThings.append(CGGetProtoObjectMethod(descriptor))
        if (descriptor.interface.hasInterfaceObject() and
                descriptor.shouldHaveGetConstructorObjectMethod()):
            cgThings.append(CGGetConstructorObjectMethod(descriptor))

        unscopableNames = []
        for m in descriptor.interface.members:
            if (m.isMethod() and
                    (not m.isIdentifierLess() or m == descriptor.operations["Stringifier"])):
                if m.getExtendedAttribute("Unscopable"):
                    assert not m.isStatic()
                    unscopableNames.append(m.identifier.name)
                if m.isStatic():
                    assert descriptor.interface.hasInterfaceObject()
                    cgThings.append(CGStaticMethod(descriptor, m))
                elif not descriptor.interface.isCallback():
                    cgThings.append(CGSpecializedMethod(descriptor, m))
                    cgThings.append(CGMemberJITInfo(descriptor, m))
            elif m.isAttr():
                if m.stringifier:
                    raise TypeError("Stringifier attributes not supported yet. "
                                    "See https://github.com/servo/servo/issues/7590\n"
                                    "%s" % m.location)
                if m.getExtendedAttribute("Unscopable"):
                    assert not m.isStatic()
                    unscopableNames.append(m.identifier.name)
                if m.isStatic():
                    assert descriptor.interface.hasInterfaceObject()
                    cgThings.append(CGStaticGetter(descriptor, m))
                elif not descriptor.interface.isCallback():
                    cgThings.append(CGSpecializedGetter(descriptor, m))

                if not m.readonly:
                    if m.isStatic():
                        assert descriptor.interface.hasInterfaceObject()
                        cgThings.append(CGStaticSetter(descriptor, m))
                    elif not descriptor.interface.isCallback():
                        cgThings.append(CGSpecializedSetter(descriptor, m))
                elif m.getExtendedAttribute("PutForwards"):
                    cgThings.append(CGSpecializedForwardingSetter(descriptor, m))

                if (not m.isStatic() and not descriptor.interface.isCallback()):
                    cgThings.append(CGMemberJITInfo(descriptor, m))

        if descriptor.concrete:
            cgThings.append(CGClassFinalizeHook(descriptor))
            cgThings.append(CGClassTraceHook(descriptor))

        if descriptor.interface.hasInterfaceObject():
            if descriptor.interface.ctor():
                cgThings.append(CGClassConstructHook(descriptor))
            for ctor in descriptor.interface.namedConstructors:
                cgThings.append(CGClassConstructHook(descriptor, ctor))
            if not descriptor.interface.isCallback():
                cgThings.append(CGInterfaceObjectJSClass(descriptor))

        if not descriptor.interface.isCallback():
            cgThings.append(CGPrototypeJSClass(descriptor))

        # If there are no constant members, don't make a module for constants
        constMembers = [m for m in descriptor.interface.members if m.isConst()]
        if constMembers:
            cgThings.append(CGNamespace.build([descriptor.name + "Constants"],
                                              CGConstant(constMembers),
                                              public=True))

        if descriptor.interface.hasInterfaceObject():
            cgThings.append(CGDefineDOMInterfaceMethod(descriptor))
            cgThings.append(CGConstructorEnabled(descriptor))

        if descriptor.proxy:
            cgThings.append(CGDefineProxyHandler(descriptor))

        if descriptor.concrete:
            if descriptor.proxy:
                # cgThings.append(CGProxyIsProxy(descriptor))
                cgThings.append(CGProxyUnwrap(descriptor))
                cgThings.append(CGDOMJSProxyHandlerDOMClass(descriptor))
                cgThings.append(CGDOMJSProxyHandler_ownPropertyKeys(descriptor))
                if descriptor.interface.getExtendedAttribute("LegacyUnenumerableNamedProperties"):
                    cgThings.append(CGDOMJSProxyHandler_getOwnEnumerablePropertyKeys(descriptor))
                cgThings.append(CGDOMJSProxyHandler_getOwnPropertyDescriptor(descriptor))
                cgThings.append(CGDOMJSProxyHandler_className(descriptor))
                cgThings.append(CGDOMJSProxyHandler_get(descriptor))
                cgThings.append(CGDOMJSProxyHandler_hasOwn(descriptor))

                if descriptor.operations['IndexedSetter'] or descriptor.operations['NamedSetter']:
                    cgThings.append(CGDOMJSProxyHandler_defineProperty(descriptor))

                # We want to prevent indexed deleters from compiling at all.
                assert not descriptor.operations['IndexedDeleter']

                if descriptor.operations['NamedDeleter']:
                    cgThings.append(CGDOMJSProxyHandler_delete(descriptor))

                # cgThings.append(CGDOMJSProxyHandler(descriptor))
                # cgThings.append(CGIsMethod(descriptor))
                pass
            else:
                cgThings.append(CGDOMJSClass(descriptor))
                pass

            cgThings.append(CGWrapMethod(descriptor))

        haveUnscopables = False
        if not descriptor.interface.isCallback():
            if unscopableNames:
                haveUnscopables = True
                cgThings.append(
                    CGList([CGGeneric("const unscopable_names: &'static [&'static [u8]] = &["),
                            CGIndenter(CGList([CGGeneric(str_to_const_array(name)) for
                                               name in unscopableNames], ",\n")),
                            CGGeneric("];\n")], "\n"))
            if descriptor.concrete or descriptor.hasDescendants():
                cgThings.append(CGIDLInterface(descriptor))
            cgThings.append(CGInterfaceTrait(descriptor))
            if descriptor.weakReferenceable:
                cgThings.append(CGWeakReferenceableTrait(descriptor))

        properties = PropertyArrays(descriptor)
        cgThings.append(CGGeneric(str(properties)))
        cgThings.append(CGCreateInterfaceObjectsMethod(descriptor, properties, haveUnscopables))

        cgThings = CGList(cgThings, "\n")
        # self.cgRoot = CGWrapper(CGNamespace(toBindingNamespace(descriptor.name),
        #                                     cgThings),
        #                         post='\n')
        self.cgRoot = cgThings

    def define(self):
        return self.cgRoot.define()


class CGNonNamespacedEnum(CGThing):
    def __init__(self, enumName, names, first, comment="", deriving="", repr=""):
        # Account for first value
        entries = ["%s = %s" % (names[0], first)] + names[1:]

        # Append a Last.
        entries.append('Last = ' + str(first + len(entries)))

        # Indent.
        entries = ['    ' + e for e in entries]

        # Build the enum body.
        enumstr = comment + 'pub enum %s {\n%s\n}\n' % (enumName, ',\n'.join(entries))
        if repr:
            enumstr = ('#[repr(%s)]\n' % repr) + enumstr
        if deriving:
            enumstr = ('#[derive(%s)]\n' % deriving) + enumstr
        curr = CGGeneric(enumstr)

        # Add some whitespace padding.
        curr = CGWrapper(curr, pre='\n', post='\n')

        # Add the typedef
        # typedef = '\ntypedef %s::%s %s;\n\n' % (namespace, enumName, enumName)
        # curr = CGList([curr, CGGeneric(typedef)])

        # Save the result.
        self.node = curr

    def define(self):
        return self.node.define()


class CGDictionary(CGThing):
    def __init__(self, dictionary, descriptorProvider):
        self.dictionary = dictionary
        if all(CGDictionary(d, descriptorProvider).generatable for
               d in CGDictionary.getDictionaryDependencies(dictionary)):
            self.generatable = True
        else:
            self.generatable = False
            # Nothing else to do here
            return

        self.memberInfo = [
            (member,
             getJSToNativeConversionInfo(member.type,
                                         descriptorProvider,
                                         isMember="Dictionary",
                                         defaultValue=member.defaultValue,
                                         exceptionCode="return Err(());"))
            for member in dictionary.members]

    def define(self):
        if not self.generatable:
            return ""
        return self.struct() + "\n" + self.impl()

    def struct(self):
        d = self.dictionary
        if d.parent:
            inheritance = "    pub parent: %s::%s,\n" % (self.makeModuleName(d.parent),
                                                         self.makeClassName(d.parent))
        else:
            inheritance = ""
        memberDecls = ["    pub %s: %s," %
                       (self.makeMemberName(m[0].identifier.name), self.getMemberType(m))
                       for m in self.memberInfo]

        return (string.Template(
                "pub struct ${selfName} {\n" +
                "${inheritance}" +
                "\n".join(memberDecls) + "\n" +
                "}").substitute({"selfName": self.makeClassName(d),
                                 "inheritance": inheritance}))

    def impl(self):
        d = self.dictionary
        if d.parent:
            initParent = "parent: try!(%s::%s::new(cx, val)),\n" % (
                self.makeModuleName(d.parent),
                self.makeClassName(d.parent))
        else:
            initParent = ""

        def memberInit(memberInfo):
            member, _ = memberInfo
            name = self.makeMemberName(member.identifier.name)
            conversion = self.getMemberConversion(memberInfo, member.type)
            return CGGeneric("%s: %s,\n" % (name, conversion.define()))

        def varInsert(varName, dictionaryName):
            insertion = ("rooted!(in(cx) let mut %s_js = UndefinedValue());\n"
                         "%s.to_jsval(cx, %s_js.handle_mut());\n"
                         "set_dictionary_property(cx, obj.handle(), \"%s\", %s_js.handle()).unwrap();"
                         % (varName, varName, varName, dictionaryName, varName))
            return CGGeneric(insertion)

        def memberInsert(memberInfo):
            member, _ = memberInfo
            name = self.makeMemberName(member.identifier.name)
            if member.optional and not member.defaultValue:
                insertion = CGIfWrapper("let Some(ref %s) = self.%s" % (name, name),
                                        varInsert(name, member.identifier.name))
            else:
                insertion = CGGeneric("let %s = &self.%s;\n%s" %
                                      (name, name, varInsert(name, member.identifier.name).define()))
            return CGGeneric("%s\n" % insertion.define())

        memberInits = CGList([memberInit(m) for m in self.memberInfo])
        memberInserts = CGList([memberInsert(m) for m in self.memberInfo])

        return string.Template(
            "impl ${selfName} {\n"
            "    pub unsafe fn empty(cx: *mut JSContext) -> ${selfName} {\n"
            "        ${selfName}::new(cx, HandleValue::null()).unwrap()\n"
            "    }\n"
            "    pub unsafe fn new(cx: *mut JSContext, val: HandleValue) -> Result<${selfName}, ()> {\n"
            "        let object = if val.get().is_null_or_undefined() {\n"
            "            ptr::null_mut()\n"
            "        } else if val.get().is_object() {\n"
            "            val.get().to_object()\n"
            "        } else {\n"
            "            throw_type_error(cx, \"Value not an object.\");\n"
            "            return Err(());\n"
            "        };\n"
            "        rooted!(in(cx) let object = object);\n"
            "        Ok(${selfName} {\n"
            "${initParent}"
            "${initMembers}"
            "        })\n"
            "    }\n"
            "}\n"
            "\n"
            "impl FromJSValConvertible for ${selfName} {\n"
            "    type Config = ();\n"
            "    unsafe fn from_jsval(cx: *mut JSContext, value: HandleValue, _option: ())\n"
            "                         -> Result<${selfName}, ()> {\n"
            "        ${selfName}::new(cx, value)\n"
            "    }\n"
            "}\n"
            "\n"
            "impl ToJSValConvertible for ${selfName} {\n"
            "    unsafe fn to_jsval(&self, cx: *mut JSContext, rval: MutableHandleValue) {\n"
            "        rooted!(in(cx) let obj = JS_NewObject(cx, ptr::null()));\n"
            "${insertMembers}"
            "        rval.set(ObjectOrNullValue(obj.get()))\n"
            "    }\n"
            "}\n").substitute({
                "selfName": self.makeClassName(d),
                "initParent": CGIndenter(CGGeneric(initParent), indentLevel=12).define(),
                "initMembers": CGIndenter(memberInits, indentLevel=12).define(),
                "insertMembers": CGIndenter(memberInserts, indentLevel=8).define(),
            })

    @staticmethod
    def makeDictionaryName(dictionary):
        return dictionary.identifier.name

    def makeClassName(self, dictionary):
        return self.makeDictionaryName(dictionary)

    @staticmethod
    def makeModuleName(dictionary):
        return getModuleFromObject(dictionary)

    def getMemberType(self, memberInfo):
        member, info = memberInfo
        declType = info.declType
        if member.optional and not member.defaultValue:
            declType = CGWrapper(info.declType, pre="Option<", post=">")
        return declType.define()

    def getMemberConversion(self, memberInfo, memberType):
        def indent(s):
            return CGIndenter(CGGeneric(s), 8).define()

        member, info = memberInfo
        templateBody = info.template
        default = info.default
        replacements = {"val": "rval.handle()"}
        conversion = string.Template(templateBody).substitute(replacements)
        if memberType.isAny():
            conversion = "%s.get()" % conversion

        assert (member.defaultValue is None) == (default is None)
        if not member.optional:
            assert default is None
            default = ("throw_type_error(cx, \"Missing required member \\\"%s\\\".\");\n"
                       "return Err(());") % member.identifier.name
        elif not default:
            default = "None"
            conversion = "Some(%s)" % conversion

        conversion = (
            "{\n"
            "rooted!(in(cx) let mut rval = UndefinedValue());\n"
            "match try!(get_dictionary_property(cx, object.handle(), \"%s\", rval.handle_mut())) {\n"
            "    true => {\n"
            "%s\n"
            "    },\n"
            "    false => {\n"
            "%s\n"
            "    },\n"
            "}\n}") % (member.identifier.name, indent(conversion), indent(default))

        return CGGeneric(conversion)

    @staticmethod
    def makeMemberName(name):
        # Can't use Rust keywords as member names.
        if name in RUST_KEYWORDS:
            return name + "_"
        return name

    @staticmethod
    def getDictionaryDependencies(dictionary):
        deps = set()
        if dictionary.parent:
            deps.add(dictionary.parent)
        for member in dictionary.members:
            if member.type.isDictionary():
                deps.add(member.type.unroll().inner)
        return deps


class CGRegisterProxyHandlersMethod(CGAbstractMethod):
    def __init__(self, descriptors):
        docs = "Create the global vtables used by the generated DOM bindings to implement JS proxies."
        CGAbstractMethod.__init__(self, None, 'RegisterProxyHandlers', 'void', [],
                                  unsafe=True, pub=True, docs=docs)
        self.descriptors = descriptors

    def definition_body(self):
        return CGList([
            CGGeneric("proxy_handlers[Proxies::%s as usize] = codegen::Bindings::%sBinding::DefineProxyHandler();"
                      % (desc.name, desc.name))
            for desc in self.descriptors
        ], "\n")


class CGRegisterProxyHandlers(CGThing):
    def __init__(self, config):
        descriptors = config.getDescriptors(proxy=True)
        length = len(descriptors)
        self.root = CGList([
            CGGeneric("pub static mut proxy_handlers: [*const libc::c_void; %d] = [0 as *const libc::c_void; %d];"
                      % (length, length)),
            CGRegisterProxyHandlersMethod(descriptors),
        ], "\n")

    def define(self):
        return self.root.define()


class CGBindingRoot(CGThing):
    """
    Root codegen class for binding generation. Instantiate the class, and call
    declare or define to generate header or cpp code (respectively).
    """
    def __init__(self, config, prefix, webIDLFile):
        descriptors = config.getDescriptors(webIDLFile=webIDLFile,
                                            hasInterfaceObject=True)
        # We also want descriptors that have an interface prototype object
        # (isCallback=False), but we don't want to include a second copy
        # of descriptors that we also matched in the previous line
        # (hence hasInterfaceObject=False).
        descriptors.extend(config.getDescriptors(webIDLFile=webIDLFile,
                                                 hasInterfaceObject=False,
                                                 isCallback=False,
                                                 register=True))

        dictionaries = config.getDictionaries(webIDLFile=webIDLFile)

        mainCallbacks = config.getCallbacks(webIDLFile=webIDLFile)
        callbackDescriptors = config.getDescriptors(webIDLFile=webIDLFile,
                                                    isCallback=True)

        enums = config.getEnums(webIDLFile)
        typedefs = config.getTypedefs(webIDLFile)

        if not (descriptors or dictionaries or mainCallbacks or callbackDescriptors or enums):
            self.root = None
            return

        # Do codegen for all the enums.
        cgthings = [CGEnum(e) for e in enums]

        # Do codegen for all the typdefs
        for t in typedefs:
            if t.innerType.isUnion():
                cgthings.extend([CGGeneric("\npub use dom::bindings::codegen::UnionTypes::%s as %s;\n\n" %
                                           (t.innerType, t.identifier.name))])
            else:
                assert not typeNeedsRooting(t.innerType, config.getDescriptorProvider)
                cgthings.extend([CGGeneric("\npub type %s = " % (t.identifier.name)),
                                 getRetvalDeclarationForType(t.innerType, config.getDescriptorProvider()),
                                 CGGeneric(";\n\n")])

        # Do codegen for all the dictionaries.
        cgthings.extend([CGDictionary(d, config.getDescriptorProvider())
                         for d in dictionaries])

        # Do codegen for all the callbacks.
        cgthings.extend(CGList([CGCallbackFunction(c, config.getDescriptorProvider()),
                                CGCallbackFunctionImpl(c)], "\n")
                        for c in mainCallbacks)

        # Do codegen for all the descriptors
        cgthings.extend([CGDescriptor(x) for x in descriptors])

        # Do codegen for all the callback interfaces.
        cgthings.extend(CGList([CGCallbackInterface(x),
                                CGCallbackFunctionImpl(x.interface)], "\n")
                        for x in callbackDescriptors)

        # And make sure we have the right number of newlines at the end
        curr = CGWrapper(CGList(cgthings, "\n\n"), post="\n\n")

        # Add imports
        curr = CGImports(curr, descriptors + callbackDescriptors, mainCallbacks, [
            'js',
            'js::{JS_CALLEE, JSCLASS_GLOBAL_SLOT_COUNT}',
            'js::{JSCLASS_IS_DOMJSCLASS, JSCLASS_IS_GLOBAL, JSCLASS_RESERVED_SLOTS_MASK}',
            'js::error::throw_type_error',
            'js::jsapi::{JSJitInfo_AliasSet, JSJitInfo_ArgType, AutoIdVector, CallArgs, FreeOp}',
            'js::jsapi::{JSITER_SYMBOLS, JSPROP_ENUMERATE, JSPROP_PERMANENT, JSPROP_READONLY, JSPROP_SHARED}',
            'js::jsapi::{JSCLASS_RESERVED_SLOTS_SHIFT, JSITER_HIDDEN, JSITER_OWNONLY}',
            'js::jsapi::{GetPropertyKeys, Handle}',
            'js::jsapi::{HandleId, HandleObject, HandleValue, HandleValueArray}',
            'js::jsapi::{INTERNED_STRING_TO_JSID, IsCallable, JS_CallFunctionValue}',
            'js::jsapi::{JS_CopyPropertiesFrom, JS_ForwardGetPropertyTo}',
            'js::jsapi::{JS_GetClass, JS_GetErrorPrototype, JS_GetFunctionPrototype}',
            'js::jsapi::{JS_GetGlobalForObject, JS_GetObjectPrototype, JS_GetProperty}',
            'js::jsapi::{JS_GetPropertyById, JS_GetPropertyDescriptorById, JS_GetReservedSlot}',
            'js::jsapi::{JS_HasProperty, JS_HasPropertyById, JS_InitializePropertiesFromCompatibleNativeObject}',
            'js::jsapi::{JS_AtomizeAndPinString, JS_NewObject, JS_NewObjectWithGivenProto}',
            'js::jsapi::{JS_NewObjectWithoutMetadata, JS_SetProperty}',
            'js::jsapi::{JS_SetPrototype, JS_SetReservedSlot, JSAutoCompartment}',
            'js::jsapi::{JSContext, JSClass, JSFreeOp, JSFunctionSpec}',
            'js::jsapi::{JSJitGetterCallArgs, JSJitInfo, JSJitMethodCallArgs, JSJitSetterCallArgs}',
            'js::jsapi::{JSNative, JSObject, JSNativeWrapper, JSPropertySpec}',
            'js::jsapi::{JSString, JSTracer, JSType, JSTypedMethodJitInfo, JSValueType}',
            'js::jsapi::{ObjectOpResult, JSJitInfo_OpType, MutableHandle, MutableHandleObject}',
            'js::jsapi::{MutableHandleValue, PropertyDescriptor, RootedObject}',
            'js::jsapi::{SymbolCode, jsid}',
            'js::jsval::JSVal',
            'js::jsval::{ObjectValue, ObjectOrNullValue, PrivateValue}',
            'js::jsval::{NullValue, UndefinedValue}',
            'js::glue::{CallJitMethodOp, CallJitGetterOp, CallJitSetterOp, CreateProxyHandler}',
            'js::glue::{GetProxyPrivate, NewProxyObject, ProxyTraps}',
            'js::glue::{RUST_JSID_IS_STRING, int_to_jsid}',
            'js::glue::AppendToAutoIdVector',
            'js::rust::{GCMethods, define_methods, define_properties}',
            'dom::bindings',
            'dom::bindings::codegen::InterfaceObjectMap',
            'dom::bindings::global::{GlobalRef, global_root_from_object, global_root_from_reflector}',
            'dom::bindings::interface::{InterfaceConstructorBehavior, NonCallbackInterfaceObjectClass}',
            'dom::bindings::interface::{create_callback_interface_object, create_interface_prototype_object}',
            'dom::bindings::interface::{create_named_constructors, create_noncallback_interface_object}',
            'dom::bindings::interface::{define_guarded_methods, define_guarded_properties}',
            'dom::bindings::interface::{ConstantSpec, NonNullJSNative}',
            'dom::bindings::interface::ConstantVal::{IntVal, UintVal}',
            'dom::bindings::interface::is_exposed_in',
            'dom::bindings::js::{JS, Root, RootedReference}',
            'dom::bindings::js::{OptionalRootedReference}',
            'dom::bindings::reflector::{Reflectable}',
            'dom::bindings::utils::{DOMClass, DOMJSClass}',
            'dom::bindings::utils::{DOM_PROTO_UNFORGEABLE_HOLDER_SLOT, JSCLASS_DOM_GLOBAL}',
            'dom::bindings::utils::{ProtoOrIfaceArray, create_dom_global}',
            'dom::bindings::utils::{enumerate_global, finalize_global, find_enum_string_index}',
            'dom::bindings::utils::{generic_getter, generic_lenient_getter, generic_lenient_setter}',
            'dom::bindings::utils::{generic_method, generic_setter, get_array_index_from_id}',
            'dom::bindings::utils::{get_dictionary_property, get_property_on_prototype}',
            'dom::bindings::utils::{get_proto_or_iface_array, has_property_on_prototype}',
            'dom::bindings::utils::{is_platform_object, resolve_global, set_dictionary_property, trace_global}',
            'dom::bindings::trace::{JSTraceable, RootedTraceable}',
            'dom::bindings::callback::{CallbackContainer,CallbackInterface,CallbackFunction}',
            'dom::bindings::callback::{CallSetup,ExceptionHandling}',
            'dom::bindings::callback::wrap_call_this_object',
            'dom::bindings::conversions::{ConversionBehavior, DOM_OBJECT_SLOT}',
            'dom::bindings::conversions::{IDLInterface, is_array_like}',
            'dom::bindings::conversions::{FromJSValConvertible, StringificationBehavior}',
            'dom::bindings::conversions::{ToJSValConvertible, jsid_to_str, native_from_handlevalue}',
            'dom::bindings::conversions::{native_from_object, private_from_object, root_from_object}',
            'dom::bindings::conversions::{root_from_handleobject, root_from_handlevalue}',
            'dom::bindings::codegen::{PrototypeList, RegisterBindings, UnionTypes}',
            'dom::bindings::codegen::Bindings::*',
            'dom::bindings::error::{Fallible, Error, ErrorResult}',
            'dom::bindings::error::Error::JSFailed',
            'dom::bindings::error::throw_dom_exception',
            'dom::bindings::guard::{Condition, Guard}',
            'dom::bindings::proxyhandler',
            'dom::bindings::proxyhandler::{ensure_expando_object, fill_property_descriptor}',
            'dom::bindings::proxyhandler::{get_expando_object, get_property_descriptor}',
            'dom::bindings::num::Finite',
            'dom::bindings::str::{ByteString, DOMString, USVString}',
            'dom::bindings::weakref::{DOM_WEAK_SLOT, WeakBox, WeakReferenceable}',
            'dom::browsingcontext::BrowsingContext',
            'mem::heap_size_of_raw_self_and_children',
            'libc',
            'util::prefs::PREFS',
            'script_runtime::{store_panic_result, maybe_take_panic_result}',
            'std::borrow::ToOwned',
            'std::cmp',
            'std::mem',
            'std::num',
            'std::os',
            'std::panic::{self, AssertUnwindSafe}',
            'std::ptr',
            'std::str',
            'std::rc',
            'std::rc::Rc',
            'std::default::Default',
            'std::ffi::CString',
        ], config)

        # Add the auto-generated comment.
        curr = CGWrapper(curr, pre=AUTOGENERATED_WARNING_COMMENT)

        # Store the final result.
        self.root = curr

    def define(self):
        if not self.root:
            return None
        return stripTrailingWhitespace(self.root.define())


def argument_type(descriptorProvider, ty, optional=False, defaultValue=None, variadic=False):
    info = getJSToNativeConversionInfo(
        ty, descriptorProvider, isArgument=True)
    declType = info.declType

    if variadic:
        if ty.isGeckoInterface():
            declType = CGWrapper(declType, pre="&[", post="]")
        else:
            declType = CGWrapper(declType, pre="Vec<", post=">")
    elif optional and not defaultValue:
        declType = CGWrapper(declType, pre="Option<", post=">")

    if ty.isDictionary():
        declType = CGWrapper(declType, pre="&")

    return declType.define()


def method_arguments(descriptorProvider, returnType, arguments, passJSBits=True, trailing=None):
    if needCx(returnType, arguments, passJSBits):
        yield "cx", "*mut JSContext"

    for argument in arguments:
        ty = argument_type(descriptorProvider, argument.type, argument.optional,
                           argument.defaultValue, argument.variadic)
        yield CGDictionary.makeMemberName(argument.identifier.name), ty

    if trailing:
        yield trailing


def return_type(descriptorProvider, rettype, infallible):
    result = getRetvalDeclarationForType(rettype, descriptorProvider)
    if not infallible:
        result = CGWrapper(result, pre="Fallible<", post=">")
    return result.define()


class CGNativeMember(ClassMethod):
    def __init__(self, descriptorProvider, member, name, signature, extendedAttrs,
                 breakAfter=True, passJSBitsAsNeeded=True, visibility="public"):
        """
        If passJSBitsAsNeeded is false, we don't automatically pass in a
        JSContext* or a JSObject* based on the return and argument types.
        """
        self.descriptorProvider = descriptorProvider
        self.member = member
        self.extendedAttrs = extendedAttrs
        self.passJSBitsAsNeeded = passJSBitsAsNeeded
        breakAfterSelf = "\n" if breakAfter else ""
        ClassMethod.__init__(self, name,
                             self.getReturnType(signature[0]),
                             self.getArgs(signature[0], signature[1]),
                             static=member.isStatic(),
                             # Mark our getters, which are attrs that
                             # have a non-void return type, as const.
                             const=(not member.isStatic() and member.isAttr() and
                                    not signature[0].isVoid()),
                             breakAfterSelf=breakAfterSelf,
                             visibility=visibility)

    def getReturnType(self, type):
        infallible = 'infallible' in self.extendedAttrs
        typeDecl = return_type(self.descriptorProvider, type, infallible)
        return typeDecl

    def getArgs(self, returnType, argList):
        return [Argument(arg[1], arg[0]) for arg in method_arguments(self.descriptorProvider,
                                                                     returnType,
                                                                     argList,
                                                                     self.passJSBitsAsNeeded)]


class CGCallback(CGClass):
    def __init__(self, idlObject, descriptorProvider, baseName, methods,
                 getters=[], setters=[]):
        self.baseName = baseName
        self._deps = idlObject.getDeps()
        name = idlObject.identifier.name
        # For our public methods that needThisHandling we want most of the
        # same args and the same return type as what CallbackMember
        # generates.  So we want to take advantage of all its
        # CGNativeMember infrastructure, but that infrastructure can't deal
        # with templates and most especially template arguments.  So just
        # cheat and have CallbackMember compute all those things for us.
        realMethods = []
        for method in methods:
            if not method.needThisHandling:
                realMethods.append(method)
            else:
                realMethods.extend(self.getMethodImpls(method))
        CGClass.__init__(self, name,
                         bases=[ClassBase(baseName)],
                         constructors=self.getConstructors(),
                         methods=realMethods + getters + setters,
                         decorators="#[derive(JSTraceable, PartialEq)]")

    def getConstructors(self):
        return [ClassConstructor(
            [Argument("*mut JSObject", "aCallback")],
            bodyInHeader=True,
            visibility="pub",
            explicit=False,
            baseConstructors=[
                "%s::new()" % self.baseName
            ])]

    def getMethodImpls(self, method):
        assert method.needThisHandling
        args = list(method.args)
        # Strip out the JSContext*/JSObject* args
        # that got added.
        assert args[0].name == "cx" and args[0].argType == "*mut JSContext"
        assert args[1].name == "aThisObj" and args[1].argType == "HandleObject"
        args = args[2:]
        # Record the names of all the arguments, so we can use them when we call
        # the private method.
        argnames = [arg.name for arg in args]
        argnamesWithThis = ["s.get_context()", "thisObjJS.handle()"] + argnames
        argnamesWithoutThis = ["s.get_context()", "thisObjJS.handle()"] + argnames
        # Now that we've recorded the argnames for our call to our private
        # method, insert our optional argument for deciding whether the
        # CallSetup should re-throw exceptions on aRv.
        args.append(Argument("ExceptionHandling", "aExceptionHandling",
                             "ReportExceptions"))

        # And now insert our template argument.
        argsWithoutThis = list(args)
        args.insert(0, Argument("&T", "thisObj"))

        # And the self argument
        method.args.insert(0, Argument(None, "&self"))
        args.insert(0, Argument(None, "&self"))
        argsWithoutThis.insert(0, Argument(None, "&self"))

        setupCall = ("let mut s_ec = RootedObject::new_unrooted(ptr::null_mut());\n"
                     "let s = CallSetup::new(&mut s_ec, self, aExceptionHandling);\n"
                     "if s.get_context().is_null() {\n"
                     "    return Err(JSFailed);\n"
                     "}\n")

        bodyWithThis = string.Template(
            setupCall +
            "rooted!(in(s.get_context()) let mut thisObjJS = ptr::null_mut());\n"
            "wrap_call_this_object(s.get_context(), thisObj, thisObjJS.handle_mut());\n"
            "if thisObjJS.is_null() {\n"
            "    return Err(JSFailed);\n"
            "}\n"
            "return ${methodName}(${callArgs});").substitute({
                "callArgs": ", ".join(argnamesWithThis),
                "methodName": 'self.' + method.name,
            })
        bodyWithoutThis = string.Template(
            setupCall +
            "rooted!(in(s.get_context()) let thisObjJS = ptr::null_mut());"
            "return ${methodName}(${callArgs});").substitute({
                "callArgs": ", ".join(argnamesWithoutThis),
                "methodName": 'self.' + method.name,
            })
        return [ClassMethod(method.name + '_', method.returnType, args,
                            bodyInHeader=True,
                            templateArgs=["T: Reflectable"],
                            body=bodyWithThis,
                            visibility='pub'),
                ClassMethod(method.name + '__', method.returnType, argsWithoutThis,
                            bodyInHeader=True,
                            body=bodyWithoutThis,
                            visibility='pub'),
                method]

    def deps(self):
        return self._deps


# We're always fallible
def callbackGetterName(attr, descriptor):
    return "Get" + MakeNativeName(
        descriptor.binaryNameFor(attr.identifier.name))


def callbackSetterName(attr, descriptor):
    return "Set" + MakeNativeName(
        descriptor.binaryNameFor(attr.identifier.name))


class CGCallbackFunction(CGCallback):
    def __init__(self, callback, descriptorProvider):
        CGCallback.__init__(self, callback, descriptorProvider,
                            "CallbackFunction",
                            methods=[CallCallback(callback, descriptorProvider)])

    def getConstructors(self):
        return CGCallback.getConstructors(self)


class CGCallbackFunctionImpl(CGGeneric):
    def __init__(self, callback):
        impl = string.Template("""\
impl CallbackContainer for ${type} {
    fn new(callback: *mut JSObject) -> Rc<${type}> {
        ${type}::new(callback)
    }

    fn callback(&self) -> *mut JSObject {
        self.parent.callback()
    }
}

impl ToJSValConvertible for ${type} {
    unsafe fn to_jsval(&self, cx: *mut JSContext, rval: MutableHandleValue) {
        self.callback().to_jsval(cx, rval);
    }
}\
""").substitute({"type": callback.identifier.name})
        CGGeneric.__init__(self, impl)


class CGCallbackInterface(CGCallback):
    def __init__(self, descriptor):
        iface = descriptor.interface
        attrs = [m for m in iface.members if m.isAttr() and not m.isStatic()]
        getters = [CallbackGetter(a, descriptor) for a in attrs]
        setters = [CallbackSetter(a, descriptor) for a in attrs
                   if not a.readonly]
        methods = [m for m in iface.members
                   if m.isMethod() and not m.isStatic() and not m.isIdentifierLess()]
        methods = [CallbackOperation(m, sig, descriptor) for m in methods
                   for sig in m.signatures()]
        assert not iface.isJSImplemented() or not iface.ctor()
        CGCallback.__init__(self, iface, descriptor, "CallbackInterface",
                            methods, getters=getters, setters=setters)


class FakeMember():
    def __init__(self):
        self.treatNullAs = "Default"

    def isStatic(self):
        return False

    def isAttr(self):
        return False

    def isMethod(self):
        return False

    def getExtendedAttribute(self, name):
        return None


class CallbackMember(CGNativeMember):
    def __init__(self, sig, name, descriptorProvider, needThisHandling):
        """
        needThisHandling is True if we need to be able to accept a specified
        thisObj, False otherwise.
        """

        self.retvalType = sig[0]
        self.originalSig = sig
        args = sig[1]
        self.argCount = len(args)
        if self.argCount > 0:
            # Check for variadic arguments
            lastArg = args[self.argCount - 1]
            if lastArg.variadic:
                self.argCountStr = (
                    "(%d - 1) + %s.len()" % (self.argCount,
                                             lastArg.identifier.name))
            else:
                self.argCountStr = "%d" % self.argCount
        self.needThisHandling = needThisHandling
        # If needThisHandling, we generate ourselves as private and the caller
        # will handle generating public versions that handle the "this" stuff.
        visibility = "priv" if needThisHandling else "pub"
        # We don't care, for callback codegen, whether our original member was
        # a method or attribute or whatnot.  Just always pass FakeMember()
        # here.
        CGNativeMember.__init__(self, descriptorProvider, FakeMember(),
                                name, (self.retvalType, args),
                                extendedAttrs={},
                                passJSBitsAsNeeded=False,
                                visibility=visibility)
        # We have to do all the generation of our body now, because
        # the caller relies on us throwing if we can't manage it.
        self.exceptionCode = "return Err(JSFailed);"
        self.body = self.getImpl()

    def getImpl(self):
        replacements = {
            "declRval": self.getRvalDecl(),
            "returnResult": self.getResultConversion(),
            "convertArgs": self.getArgConversions(),
            "doCall": self.getCall(),
            "setupCall": self.getCallSetup(),
        }
        if self.argCount > 0:
            replacements["argCount"] = self.argCountStr
            replacements["argvDecl"] = string.Template(
                "let mut argv = vec![UndefinedValue(); ${argCount}];\n"
            ).substitute(replacements)
        else:
            # Avoid weird 0-sized arrays
            replacements["argvDecl"] = ""

        # Newlines and semicolons are in the values
        pre = string.Template(
            "${setupCall}"
            "${declRval}"
            "${argvDecl}").substitute(replacements)
        body = string.Template(
            "${convertArgs}"
            "${doCall}"
            "${returnResult}").substitute(replacements)
        return CGWrapper(CGIndenter(CGList([
            CGGeneric(pre),
            CGGeneric(body),
        ], "\n"), 4), pre="unsafe {\n", post="\n}").define()

    def getResultConversion(self):
        replacements = {
            "val": "rval.handle()",
        }

        info = getJSToNativeConversionInfo(
            self.retvalType,
            self.descriptorProvider,
            exceptionCode=self.exceptionCode,
            isCallbackReturnValue="Callback",
            # XXXbz we should try to do better here
            sourceDescription="return value")
        template = info.template
        declType = info.declType

        convertType = instantiateJSToNativeConversionTemplate(
            template, replacements, declType, "rvalDecl")

        if self.retvalType is None or self.retvalType.isVoid():
            retval = "()"
        elif self.retvalType.isAny():
            retval = "rvalDecl.get()"
        else:
            retval = "rvalDecl"

        return "%s\nOk(%s)\n" % (convertType.define(), retval)

    def getArgConversions(self):
        # Just reget the arglist from self.originalSig, because our superclasses
        # just have way to many members they like to clobber, so I can't find a
        # safe member name to store it in.
        argConversions = [self.getArgConversion(i, arg) for (i, arg)
                          in enumerate(self.originalSig[1])]
        # Do them back to front, so our argc modifications will work
        # correctly, because we examine trailing arguments first.
        argConversions.reverse()
        argConversions = [CGGeneric(c) for c in argConversions]
        if self.argCount > 0:
            argConversions.insert(0, self.getArgcDecl())
        # And slap them together.
        return CGList(argConversions, "\n\n").define() + "\n\n"

    def getArgConversion(self, i, arg):
        argval = arg.identifier.name

        if arg.variadic:
            argval = argval + "[idx].get()"
            jsvalIndex = "%d + idx" % i
        else:
            jsvalIndex = "%d" % i
            if arg.optional and not arg.defaultValue:
                argval += ".clone().unwrap()"

        conversion = wrapForType(
            "argv_root.handle_mut()", result=argval,
            successCode="argv[%s] = argv_root.get();" % jsvalIndex,
            pre="rooted!(in(cx) let mut argv_root = UndefinedValue());")
        if arg.variadic:
            conversion = string.Template(
                "for idx in 0..${arg}.len() {\n" +
                CGIndenter(CGGeneric(conversion)).define() + "\n"
                "}"
            ).substitute({"arg": arg.identifier.name})
        elif arg.optional and not arg.defaultValue:
            conversion = (
                CGIfWrapper("%s.is_some()" % arg.identifier.name,
                            CGGeneric(conversion)).define() +
                " else if argc == %d {\n"
                "    // This is our current trailing argument; reduce argc\n"
                "    argc -= 1;\n"
                "} else {\n"
                "    argv[%d] = UndefinedValue();\n"
                "}" % (i + 1, i))
        return conversion

    def getArgs(self, returnType, argList):
        args = CGNativeMember.getArgs(self, returnType, argList)
        if not self.needThisHandling:
            # Since we don't need this handling, we're the actual method that
            # will be called, so we need an aRethrowExceptions argument.
            args.append(Argument("ExceptionHandling", "aExceptionHandling",
                                 "ReportExceptions"))
            return args
        # We want to allow the caller to pass in a "this" object, as
        # well as a JSContext.
        return [Argument("*mut JSContext", "cx"),
                Argument("HandleObject", "aThisObj")] + args

    def getCallSetup(self):
        if self.needThisHandling:
            # It's been done for us already
            return ""
        return (
            "CallSetup s(CallbackPreserveColor(), aRv, aExceptionHandling);\n"
            "JSContext* cx = s.get_context();\n"
            "if (!cx) {\n"
            "    return Err(JSFailed);\n"
            "}\n")

    def getArgcDecl(self):
        if self.argCount <= 1:
            return CGGeneric("let argc = %s;" % self.argCountStr)
        return CGGeneric("let mut argc = %s;" % self.argCountStr)

    @staticmethod
    def ensureASCIIName(idlObject):
        type = "attribute" if idlObject.isAttr() else "operation"
        if re.match("[^\x20-\x7E]", idlObject.identifier.name):
            raise SyntaxError('Callback %s name "%s" contains non-ASCII '
                              "characters.  We can't handle that.  %s" %
                              (type, idlObject.identifier.name,
                               idlObject.location))
        if re.match('"', idlObject.identifier.name):
            raise SyntaxError("Callback %s name '%s' contains "
                              "double-quote character.  We can't handle "
                              "that.  %s" %
                              (type, idlObject.identifier.name,
                               idlObject.location))


class CallbackMethod(CallbackMember):
    def __init__(self, sig, name, descriptorProvider, needThisHandling):
        CallbackMember.__init__(self, sig, name, descriptorProvider,
                                needThisHandling)

    def getRvalDecl(self):
        return "rooted!(in(cx) let mut rval = UndefinedValue());\n"

    def getCall(self):
        replacements = {
            "thisObj": self.getThisObj(),
            "getCallable": self.getCallableDecl()
        }
        if self.argCount > 0:
            replacements["argv"] = "argv.as_ptr()"
            replacements["argc"] = "argc"
        else:
            replacements["argv"] = "ptr::null_mut()"
            replacements["argc"] = "0"
        return string.Template(
            "${getCallable}"
            "rooted!(in(cx) let rootedThis = ${thisObj});\n"
            "let ok = JS_CallFunctionValue(\n"
            "    cx, rootedThis.handle(), callable.handle(),\n"
            "    &HandleValueArray {\n"
            "        length_: ${argc} as ::libc::size_t,\n"
            "        elements_: ${argv}\n"
            "    }, rval.handle_mut());\n"
            "if let Some(error) = maybe_take_panic_result() {\n"
            "    panic::resume_unwind(error);\n"
            "}\n"
            "if !ok {\n"
            "    return Err(JSFailed);\n"
            "}\n").substitute(replacements)


class CallCallback(CallbackMethod):
    def __init__(self, callback, descriptorProvider):
        CallbackMethod.__init__(self, callback.signatures()[0], "Call",
                                descriptorProvider, needThisHandling=True)

    def getThisObj(self):
        return "aThisObj.get()"

    def getCallableDecl(self):
        return "rooted!(in(cx) let callable = ObjectValue(&*self.parent.callback()));\n"


class CallbackOperationBase(CallbackMethod):
    """
    Common class for implementing various callback operations.
    """
    def __init__(self, signature, jsName, nativeName, descriptor, singleOperation):
        self.singleOperation = singleOperation
        self.methodName = jsName
        CallbackMethod.__init__(self, signature, nativeName, descriptor, singleOperation)

    def getThisObj(self):
        if not self.singleOperation:
            return "self.parent.callback()"
        # This relies on getCallableDecl declaring a boolean
        # isCallable in the case when we're a single-operation
        # interface.
        return "if isCallable { aThisObj.get() } else { self.parent.callback() }"

    def getCallableDecl(self):
        replacements = {
            "methodName": self.methodName
        }
        getCallableFromProp = string.Template(
            'try!(self.parent.get_callable_property(cx, "${methodName}"))'
        ).substitute(replacements)
        if not self.singleOperation:
            return 'rooted!(in(cx) let callable =\n' + getCallableFromProp + ');\n'
        return (
            'let isCallable = IsCallable(self.parent.callback());\n'
            'rooted!(in(cx) let callable =\n' +
            CGIndenter(
                CGIfElseWrapper('isCallable',
                                CGGeneric('ObjectValue(&*self.parent.callback())'),
                                CGGeneric(getCallableFromProp))).define() + ');\n')


class CallbackOperation(CallbackOperationBase):
    """
    Codegen actual WebIDL operations on callback interfaces.
    """
    def __init__(self, method, signature, descriptor):
        self.ensureASCIIName(method)
        jsName = method.identifier.name
        CallbackOperationBase.__init__(self, signature,
                                       jsName,
                                       MakeNativeName(descriptor.binaryNameFor(jsName)),
                                       descriptor, descriptor.interface.isSingleOperationInterface())


class CallbackGetter(CallbackMember):
    def __init__(self, attr, descriptor):
        self.ensureASCIIName(attr)
        self.attrName = attr.identifier.name
        CallbackMember.__init__(self,
                                (attr.type, []),
                                callbackGetterName(attr),
                                descriptor,
                                needThisHandling=False)

    def getRvalDecl(self):
        return "JS::Rooted<JS::Value> rval(cx, JS::UndefinedValue());\n"

    def getCall(self):
        replacements = {
            "attrName": self.attrName
        }
        return string.Template(
            'if (!JS_GetProperty(cx, mCallback, "${attrName}", &rval)) {\n'
            '    return Err(JSFailed);\n'
            '}\n').substitute(replacements)


class CallbackSetter(CallbackMember):
    def __init__(self, attr, descriptor):
        self.ensureASCIIName(attr)
        self.attrName = attr.identifier.name
        CallbackMember.__init__(self,
                                (BuiltinTypes[IDLBuiltinType.Types.void],
                                 [FakeArgument(attr.type, attr)]),
                                callbackSetterName(attr),
                                descriptor,
                                needThisHandling=False)

    def getRvalDecl(self):
        # We don't need an rval
        return ""

    def getCall(self):
        replacements = {
            "attrName": self.attrName,
            "argv": "argv.handleAt(0)",
        }
        return string.Template(
            'MOZ_ASSERT(argv.length() == 1);\n'
            'if (!JS_SetProperty(cx, mCallback, "${attrName}", ${argv})) {\n'
            '    return Err(JSFailed);\n'
            '}\n').substitute(replacements)

    def getArgcDecl(self):
        return None


def camel_to_upper_snake(s):
    return "_".join(m.group(0).upper() for m in re.finditer("[A-Z][a-z]*", s))


class GlobalGenRoots():
    """
    Roots for global codegen.

    To generate code, call the method associated with the target, and then
    call the appropriate define/declare method.
    """

    @staticmethod
    def InterfaceObjectMap(config):
        mods = [
            "dom::bindings::codegen",
            "js::jsapi::{HandleObject, JSContext}",
            "phf",
        ]
        imports = CGList([CGGeneric("use %s;" % mod) for mod in mods], "\n")

        global_descriptors = config.getDescriptors(isGlobal=True)
        flags = [("EMPTY", 0)]
        flags.extend(
            (camel_to_upper_snake(d.name), 2 ** idx)
            for (idx, d) in enumerate(global_descriptors)
        )
        global_flags = CGWrapper(CGIndenter(CGList([
            CGGeneric("const %s = %#x," % args)
            for args in flags
        ], "\n")), pre="pub flags Globals: u8 {\n", post="\n}")
        globals_ = CGWrapper(CGIndenter(global_flags), pre="bitflags! {\n", post="\n}")

        pairs = []
        for d in config.getDescriptors(hasInterfaceObject=True):
            binding = toBindingNamespace(d.name)
            pairs.append((d.name, binding))
            for ctor in d.interface.namedConstructors:
                pairs.append((ctor.identifier.name, binding))
        pairs.sort(key=operator.itemgetter(0))
        mappings = [
            CGGeneric('b"%s" => codegen::Bindings::%s::DefineDOMInterface as unsafe fn(_, _),' % pair)
            for pair in pairs
        ]
        mapType = "phf::Map<&'static [u8], unsafe fn(*mut JSContext, HandleObject)>"
        phf = CGWrapper(
            CGIndenter(CGList(mappings, "\n")),
            pre="pub static MAP: %s = phf_map! {\n" % mapType,
            post="\n};\n")

        return CGList([
            CGGeneric(AUTOGENERATED_WARNING_COMMENT),
            CGList([imports, globals_, phf], "\n\n")
        ])

    @staticmethod
    def PrototypeList(config):
        # Prototype ID enum.
        interfaces = config.getDescriptors(isCallback=False)
        protos = [d.name for d in interfaces]
        constructors = [d.name for d in config.getDescriptors(hasInterfaceObject=True)
                        if d.shouldHaveGetConstructorObjectMethod()]
        proxies = [d.name for d in config.getDescriptors(proxy=True)]

        return CGList([
            CGGeneric(AUTOGENERATED_WARNING_COMMENT),
            CGGeneric("pub const PROTO_OR_IFACE_LENGTH: usize = %d;\n" % (len(protos) + len(constructors))),
            CGGeneric("pub const MAX_PROTO_CHAIN_LENGTH: usize = %d;\n\n" % config.maxProtoChainLength),
            CGNonNamespacedEnum('ID', protos, 0, deriving="PartialEq, Copy, Clone", repr="u16"),
            CGNonNamespacedEnum('Constructor', constructors, len(protos),
                                deriving="PartialEq, Copy, Clone", repr="u16"),
            CGWrapper(CGIndenter(CGList([CGGeneric('"' + name + '"') for name in protos],
                                        ",\n"),
                                 indentLevel=4),
                      pre="static INTERFACES: [&'static str; %d] = [\n" % len(protos),
                      post="\n];\n\n"),
            CGGeneric("pub fn proto_id_to_name(proto_id: u16) -> &'static str {\n"
                      "    debug_assert!(proto_id < ID::Last as u16);\n"
                      "    INTERFACES[proto_id as usize]\n"
                      "}\n\n"),
            CGNonNamespacedEnum('Proxies', proxies, 0, deriving="PartialEq, Copy, Clone"),
        ])

    @staticmethod
    def RegisterBindings(config):
        # TODO - Generate the methods we want
        code = CGList([
            CGRegisterProxyHandlers(config),
        ], "\n")

        return CGImports(code, [], [], [
            'dom::bindings::codegen',
            'dom::bindings::codegen::PrototypeList::Proxies',
            'libc',
        ], config, ignored_warnings=[])

    @staticmethod
    def InterfaceTypes(config):
        descriptors = [d.name for d in config.getDescriptors(register=True, isCallback=False)]
        curr = CGList([CGGeneric("pub use dom::%s::%s;\n" % (name.lower(), name)) for name in descriptors])
        curr = CGWrapper(curr, pre=AUTOGENERATED_WARNING_COMMENT)
        return curr

    @staticmethod
    def Bindings(config):

        descriptors = (set(d.name + "Binding" for d in config.getDescriptors(register=True)) |
                       set(getModuleFromObject(d) for d in config.callbacks) |
                       set(getModuleFromObject(d) for d in config.getDictionaries()))
        curr = CGList([CGGeneric("pub mod %s;\n" % name) for name in sorted(descriptors)])
        curr = CGWrapper(curr, pre=AUTOGENERATED_WARNING_COMMENT)
        return curr

    @staticmethod
    def InheritTypes(config):

        descriptors = config.getDescriptors(register=True, isCallback=False)
        imports = [CGGeneric("use dom::types::*;\n"),
                   CGGeneric("use dom::bindings::conversions::{DerivedFrom, get_dom_class};\n"),
                   CGGeneric("use dom::bindings::inheritance::Castable;\n"),
                   CGGeneric("use dom::bindings::js::{JS, LayoutJS, Root};\n"),
                   CGGeneric("use dom::bindings::trace::JSTraceable;\n"),
                   CGGeneric("use dom::bindings::reflector::Reflectable;\n"),
                   CGGeneric("use js::jsapi::JSTracer;\n\n"),
                   CGGeneric("use std::mem;\n\n")]
        allprotos = []
        topTypes = []
        hierarchy = defaultdict(list)
        for descriptor in descriptors:
            name = descriptor.name
            chain = descriptor.prototypeChain
            upcast = descriptor.hasDescendants()
            downcast = len(chain) != 1

            if upcast and not downcast:
                topTypes.append(name)

            if not upcast:
                # No other interface will implement DeriveFrom<Foo> for this Foo, so avoid
                # implementing it for itself.
                chain = chain[:-1]

            # Implement `DerivedFrom<Bar>` for `Foo`, for all `Bar` that `Foo` inherits from.
            if chain:
                allprotos.append(CGGeneric("impl Castable for %s {}\n" % name))
            for baseName in chain:
                allprotos.append(CGGeneric("impl DerivedFrom<%s> for %s {}\n" % (baseName, name)))
            if chain:
                allprotos.append(CGGeneric("\n"))

            if downcast:
                hierarchy[descriptor.getParentName()].append(name)

        typeIdCode = []
        topTypeVariants = [
            ("ID used by abstract interfaces.", "Abstract"),
            ("ID used by interfaces that are not castable.", "Alone"),
        ]
        topTypeVariants += [
            ("ID used by interfaces that derive from %s." % typeName, "%s(%sTypeId)" % (typeName, typeName))
            for typeName in topTypes
        ]
        topTypeVariantsAsStrings = [CGGeneric("/// %s\n%s," % variant) for variant in topTypeVariants]
        typeIdCode.append(CGWrapper(CGIndenter(CGList(topTypeVariantsAsStrings, "\n"), 4),
                                    pre="#[derive(Clone, Copy, Debug)]\npub enum TopTypeId {\n",
                                    post="\n}\n\n"))

        def type_id_variant(name):
            # If `name` is present in the hierarchy keys', that means some other interfaces
            # derive from it and this enum variant should have an argument with its own
            # TypeId enum.
            return "%s(%sTypeId)" % (name, name) if name in hierarchy else name

        for base, derived in hierarchy.iteritems():
            variants = []
            if not config.getInterface(base).getExtendedAttribute("Abstract"):
                variants.append(CGGeneric(base))
            variants += [CGGeneric(type_id_variant(derivedName)) for derivedName in derived]
            derives = "Clone, Copy, Debug, PartialEq"
            typeIdCode.append(CGWrapper(CGIndenter(CGList(variants, ",\n"), 4),
                                        pre="#[derive(%s)]\npub enum %sTypeId {\n" % (derives, base),
                                        post="\n}\n\n"))
            if base in topTypes:
                typeIdCode.append(CGGeneric("""\
impl %(base)s {
    pub fn type_id(&self) -> &'static %(base)sTypeId {
        let domclass = unsafe {
            get_dom_class(self.reflector().get_jsobject().get()).unwrap()
        };
        match domclass.type_id {
            TopTypeId::%(base)s(ref type_id) => type_id,
            _ => unreachable!(),
        }
    }
}

""" % {'base': base}))

        curr = CGList(imports + typeIdCode + allprotos)
        curr = CGWrapper(curr, pre=AUTOGENERATED_WARNING_COMMENT)
        return curr

    @staticmethod
    def UnionTypes(config):

        curr = UnionTypes(config.getDescriptors(),
                          config.getDictionaries(),
                          config.getCallbacks(),
                          config)

        # Add the auto-generated comment.
        curr = CGWrapper(curr, pre=AUTOGENERATED_WARNING_COMMENT)

        # Done.
        return curr

    @staticmethod
    def SupportedDomApis(config):
        descriptors = config.getDescriptors(isExposedConditionally=False)

        base_path = os.path.join('dom', 'bindings', 'codegen')
        with open(os.path.join(base_path, 'apis.html.template')) as f:
            base_template = f.read()
        with open(os.path.join(base_path, 'api.html.template')) as f:
            api_template = f.read()
        with open(os.path.join(base_path, 'property.html.template')) as f:
            property_template = f.read()
        with open(os.path.join(base_path, 'interface.html.template')) as f:
            interface_template = f.read()

        apis = []
        interfaces = []
        for descriptor in descriptors:
            props = []
            for m in descriptor.interface.members:
                if PropertyDefiner.getStringAttr(m, 'Pref') or \
                   PropertyDefiner.getStringAttr(m, 'Func') or \
                   (m.isMethod() and m.isIdentifierLess()):
                    continue
                display = m.identifier.name + ('()' if m.isMethod() else '')
                props += [property_template.replace('${name}', display)]
            name = descriptor.interface.identifier.name
            apis += [(api_template.replace('${interface}', name)
                                  .replace('${properties}', '\n'.join(props)))]
            interfaces += [interface_template.replace('${interface}', name)]

        return CGGeneric((base_template.replace('${apis}', '\n'.join(apis))
                                       .replace('${interfaces}', '\n'.join(interfaces))))