diff options
Diffstat (limited to 'dom/bindings/Configuration.py')
| -rw-r--r-- | dom/bindings/Configuration.py | 1454 |
1 files changed, 1454 insertions, 0 deletions
diff --git a/dom/bindings/Configuration.py b/dom/bindings/Configuration.py new file mode 100644 index 0000000000..266a8db34a --- /dev/null +++ b/dom/bindings/Configuration.py @@ -0,0 +1,1454 @@ +# This Source Code Form is subject to the terms of the Mozilla Public +# License, v. 2.0. If a copy of the MPL was not distributed with this file, +# You can obtain one at http://mozilla.org/MPL/2.0/. + +import io +import itertools +import os +from collections import defaultdict + +import six +from WebIDL import IDLIncludesStatement + +autogenerated_comment = "/* THIS FILE IS AUTOGENERATED - DO NOT EDIT */\n" + + +def toStringBool(arg): + """ + Converts IDL/Python Boolean (True/False) to C++ Boolean (true/false) + """ + return str(not not arg).lower() + + +class DescriptorProvider: + """ + A way of getting descriptors for interface names. Subclasses must + have a getDescriptor method callable with the interface name only. + + Subclasses must also have a getConfig() method that returns a + Configuration. + """ + + def __init__(self): + pass + + +def isChildPath(path, basePath): + path = os.path.normpath(path) + return os.path.commonprefix((path, basePath)) == basePath + + +class Configuration(DescriptorProvider): + """ + Represents global configuration state based on IDL parse data and + the configuration file. + """ + + def __init__(self, filename, webRoots, parseData, generatedEvents=[]): + DescriptorProvider.__init__(self) + + # Read the configuration file. + glbl = {} + exec(io.open(filename, encoding="utf-8").read(), glbl) + config = glbl["DOMInterfaces"] + + class IDLAttrGetterOrSetterTemplate: + def __init__(self, template, getter, setter, argument, attrName): + class TemplateAdditionalArg: + def __init__(self, type, name, value=None): + self.type = type + self.name = name + self.value = value + + self.descriptor = None + self.usedInOtherInterfaces = False + self.getter = getter + self.setter = setter + self.argument = TemplateAdditionalArg(*argument) + self.attrNameString = attrName + self.attr = None + + self.attributeTemplates = dict() + attributeTemplatesByInterface = dict() + for interface, templates in glbl["TemplatedAttributes"].items(): + for template in templates: + name = template.get("template") + t = IDLAttrGetterOrSetterTemplate(**template) + self.attributeTemplates[name] = t + attributeTemplatesByInterface.setdefault(interface, list()).append(t) + + webRoots = tuple(map(os.path.normpath, webRoots)) + + def isInWebIDLRoot(path): + return any(isChildPath(path, root) for root in webRoots) + + # Build descriptors for all the interfaces we have in the parse data. + # This allows callers to specify a subset of interfaces by filtering + # |parseData|. + self.descriptors = [] + self.interfaces = {} + self.descriptorsByName = {} + self.dictionariesByName = {} + self.generatedEvents = generatedEvents + self.maxProtoChainLength = 0 + for thing in parseData: + if isinstance(thing, IDLIncludesStatement): + # Our build system doesn't support dep build involving + # addition/removal of "includes" statements that appear in a + # different .webidl file than their LHS interface. Make sure we + # don't have any of those. See similar block below for partial + # interfaces! + if thing.interface.filename() != thing.filename(): + raise TypeError( + "The binding build system doesn't really support " + "'includes' statements which don't appear in the " + "file in which the left-hand side of the statement is " + "defined.\n" + "%s\n" + "%s" % (thing.location, thing.interface.location) + ) + + assert not thing.isType() + + if ( + not thing.isInterface() + and not thing.isNamespace() + and not thing.isInterfaceMixin() + ): + continue + # Our build system doesn't support dep builds involving + # addition/removal of partial interfaces/namespaces/mixins that + # appear in a different .webidl file than the + # interface/namespace/mixin they are extending. Make sure we don't + # have any of those. See similar block above for "includes" + # statements! + if not thing.isExternal(): + for partial in thing.getPartials(): + if partial.filename() != thing.filename(): + raise TypeError( + "The binding build system doesn't really support " + "partial interfaces/namespaces/mixins which don't " + "appear in the file in which the " + "interface/namespace/mixin they are extending is " + "defined. Don't do this.\n" + "%s\n" + "%s" % (partial.location, thing.location) + ) + + # The rest of the logic doesn't apply to mixins. + if thing.isInterfaceMixin(): + continue + + iface = thing + if not iface.isExternal(): + if not ( + iface.getExtendedAttribute("ChromeOnly") + or iface.getExtendedAttribute("Func") + == ["nsContentUtils::IsCallerChromeOrFuzzingEnabled"] + or not iface.hasInterfaceObject() + or isInWebIDLRoot(iface.filename()) + ): + raise TypeError( + "Interfaces which are exposed to the web may only be " + "defined in a DOM WebIDL root %r. Consider marking " + "the interface [ChromeOnly] or " + "[Func='nsContentUtils::IsCallerChromeOrFuzzingEnabled'] " + "if you do not want it exposed to the web.\n" + "%s" % (webRoots, iface.location) + ) + + self.interfaces[iface.identifier.name] = iface + + entry = config.pop(iface.identifier.name, {}) + assert not isinstance(entry, list) + + desc = Descriptor( + self, + iface, + entry, + attributeTemplatesByInterface.get(iface.identifier.name), + ) + self.descriptors.append(desc) + # Setting up descriptorsByName while iterating through interfaces + # means we can get the nativeType of iterable interfaces without + # having to do multiple loops. + assert desc.interface.identifier.name not in self.descriptorsByName + self.descriptorsByName[desc.interface.identifier.name] = desc + + if len(config) > 0: + raise NoSuchDescriptorError( + "Bindings.conf contains entries for " + + str(list(config)) + + " that aren't declared as interfaces in the .webidl files." + ) + + # Keep the descriptor list sorted for determinism. + self.descriptors.sort(key=lambda x: x.name) + + self.descriptorsByFile = {} + for d in self.descriptors: + self.descriptorsByFile.setdefault(d.interface.filename(), []).append(d) + + self.enums = [e for e in parseData if e.isEnum()] + + self.dictionaries = [d for d in parseData if d.isDictionary()] + self.dictionariesByName = {d.identifier.name: d for d in self.dictionaries} + + self.callbacks = [ + c for c in parseData if c.isCallback() and not c.isInterface() + ] + + # Dictionary mapping from a union type name to a set of filenames where + # union types with that name are used. + self.filenamesPerUnion = defaultdict(set) + + # Dictionary mapping from a filename to a list of types for + # the union types used in that file. If a union type is used + # in multiple files then it will be added to the list for the + # None key. Note that the list contains a type for every use + # of a union type, so there can be multiple entries with union + # types that have the same name. + self.unionsPerFilename = defaultdict(list) + + def addUnion(t): + filenamesForUnion = self.filenamesPerUnion[t.name] + if t.filename() not in filenamesForUnion: + # We have a to be a bit careful: some of our built-in + # typedefs are for unions, and those unions end up with + # "<unknown>" as the filename. If that happens, we don't + # want to try associating this union with one particular + # filename, since there isn't one to associate it with, + # really. + if t.filename() == "<unknown>": + uniqueFilenameForUnion = None + elif len(filenamesForUnion) == 0: + # This is the first file that we found a union with this + # name in, record the union as part of the file. + uniqueFilenameForUnion = t.filename() + else: + # We already found a file that contains a union with + # this name. + if len(filenamesForUnion) == 1: + # This is the first time we found a union with this + # name in another file. + for f in filenamesForUnion: + # Filter out unions with this name from the + # unions for the file where we previously found + # them. + unionsForFilename = [ + u for u in self.unionsPerFilename[f] if u.name != t.name + ] + if len(unionsForFilename) == 0: + del self.unionsPerFilename[f] + else: + self.unionsPerFilename[f] = unionsForFilename + # Unions with this name appear in multiple files, record + # the filename as None, so that we can detect that. + uniqueFilenameForUnion = None + self.unionsPerFilename[uniqueFilenameForUnion].append(t) + filenamesForUnion.add(t.filename()) + + def addUnions(t): + t = findInnermostType(t) + if t.isUnion(): + addUnion(t) + for m in t.flatMemberTypes: + addUnions(m) + + for t, _ in getAllTypes(self.descriptors, self.dictionaries, self.callbacks): + addUnions(t) + + for d in getDictionariesConvertedToJS( + self.descriptors, self.dictionaries, self.callbacks + ): + d.needsConversionToJS = True + + for d in getDictionariesConvertedFromJS( + self.descriptors, self.dictionaries, self.callbacks + ): + d.needsConversionFromJS = True + + # Collect all the global names exposed on a Window object (to implement + # the hash for looking up these names when resolving a property). + self.windowGlobalNames = [] + for desc in self.getDescriptors(registersGlobalNamesOnWindow=True): + self.windowGlobalNames.append((desc.name, desc)) + self.windowGlobalNames.extend( + (n.identifier.name, desc) for n in desc.interface.legacyFactoryFunctions + ) + self.windowGlobalNames.extend( + (n, desc) for n in desc.interface.legacyWindowAliases + ) + + # Collect a sorted list of strings that we want to concatenate into + # one big string and a dict mapping each string to its offset in the + # concatenated string. + + # We want the names of all the interfaces with a prototype (for + # implementing @@toStringTag). + names = set( + d.interface.getClassName() + for d in self.getDescriptors(hasInterfaceOrInterfacePrototypeObject=True) + ) + + # Now also add the names from windowGlobalNames, we need them for the + # perfect hash that we build for these. + names.update(n[0] for n in self.windowGlobalNames) + + # Sorting is not strictly necessary, but makes the generated code a bit + # more readable. + names = sorted(names) + + # We can't rely on being able to pass initial=0 to itertools.accumulate + # because it was only added in version 3.8, so define an accumulate + # function that chains the initial value into the iterator. + def accumulate(iterable, initial): + return itertools.accumulate(itertools.chain([initial], iterable)) + + # Calculate the offset of each name in the concatenated string. Note that + # we need to add 1 to the length to account for the null terminating each + # name. + offsets = accumulate(map(lambda n: len(n) + 1, names), initial=0) + self.namesStringOffsets = list(zip(names, offsets)) + + allTemplatedAttributes = ( + (m, d) + for d in self.descriptors + if not d.interface.isExternal() + for m in d.interface.members + if m.isAttr() and m.getExtendedAttribute("BindingTemplate") is not None + ) + # attributesPerTemplate will have the template names as keys, and a + # list of tuples as values. Every tuple contains an IDLAttribute and a + # descriptor. + attributesPerTemplate = dict() + for m, d in allTemplatedAttributes: + t = m.getExtendedAttribute("BindingTemplate") + if isinstance(t[0], list): + t = t[0] + l = attributesPerTemplate.setdefault(t[0], list()) + # We want the readonly attributes last, because we use the first + # attribute in the list as the canonical attribute for the + # template, and if there are any writable attributes the + # template should have support for that. + if not m.readonly: + l.insert(0, (m, d)) + else: + l.append((m, d)) + + for name, attributes in attributesPerTemplate.items(): + # We use the first attribute to generate a canonical implementation + # of getter and setter. + firstAttribute, firstDescriptor = attributes[0] + template = self.attributeTemplates.get(name) + if template is None: + raise TypeError( + "Unknown BindingTemplate with name %s for %s on %s" + % ( + name, + firstAttribute.identifier.name, + firstDescriptor.interface.identifier.name, + ) + ) + + # This mimics a real IDL attribute for templated bindings. + class TemplateIDLAttribute: + def __init__(self, attr): + assert attr.isAttr() + assert not attr.isMaplikeOrSetlikeAttr() + assert not attr.slotIndices + + self.identifier = attr.identifier + self.type = attr.type + self.extendedAttributes = attr.getExtendedAttributes() + self.slotIndices = None + + def getExtendedAttribute(self, name): + return self.extendedAttributes.get(name) + + def isAttr(self): + return True + + def isMaplikeOrSetlikeAttr(self): + return False + + def isMethod(self): + return False + + def isStatic(self): + return False + + template.attr = TemplateIDLAttribute(firstAttribute) + + def filterExtendedAttributes(extendedAttributes): + # These are the extended attributes that we allow to have + # different values among all attributes that use the same + # template. + ignoredAttributes = { + "BindingTemplate", + "BindingAlias", + "ChromeOnly", + "Pure", + "Pref", + "Func", + "Throws", + "GetterThrows", + "SetterThrows", + } + return dict( + filter( + lambda i: i[0] not in ignoredAttributes, + extendedAttributes.items(), + ) + ) + + firstExtAttrs = filterExtendedAttributes( + firstAttribute.getExtendedAttributes() + ) + + for a, d in attributes: + # We want to make sure all getters or setters grouped by a + # template have the same WebIDL signatures, so make sure + # their types are the same. + if template.attr.type != a.type: + raise TypeError( + "%s on %s and %s on %s have different type, but they're using the same template %s." + % ( + firstAttribute.identifier.name, + firstDescriptor.interface.identifier.name, + a.identifier.name, + d.interface.identifier.name, + name, + ) + ) + + extAttrs = filterExtendedAttributes(a.getExtendedAttributes()) + if template.attr.extendedAttributes != extAttrs: + for k in extAttrs.keys() - firstExtAttrs.keys(): + raise TypeError( + "%s on %s has extended attribute %s and %s on %s does not, but they're using the same template %s." + % ( + a.identifier.name, + d.interface.identifier.name, + k, + firstAttribute.identifier.name, + firstDescriptor.interface.identifier.name, + name, + ) + ) + for k in firstExtAttrs.keys() - extAttrs.keys(): + raise TypeError( + "%s on %s has extended attribute %s and %s on %s does not, but they're using the same template %s." + % ( + firstAttribute.identifier.name, + firstDescriptor.interface.identifier.name, + k, + a.identifier.name, + d.interface.identifier.name, + name, + ) + ) + for k, v in firstExtAttrs.items(): + if extAttrs[k] != v: + raise TypeError( + "%s on %s and %s on %s have different values for extended attribute %s, but they're using the same template %s." + % ( + firstAttribute.identifier.name, + firstDescriptor.interface.identifier.name, + a.identifier.name, + d.interface.identifier.name, + k, + name, + ) + ) + + def sameThrows(getter=False, setter=False): + extAttrs1 = firstDescriptor.getExtendedAttributes( + firstAttribute, getter=getter, setter=setter + ) + extAttrs2 = d.getExtendedAttributes(a, getter=getter, setter=setter) + return ("needsErrorResult" in extAttrs1) == ( + "needsErrorResult" in extAttrs2 + ) + + if not sameThrows(getter=True) or ( + not a.readonly and not sameThrows(setter=True) + ): + raise TypeError( + "%s on %s and %s on %s have different annotations about throwing, but they're using the same template %s." + % ( + firstAttribute.identifier.name, + firstDescriptor.interface.identifier.name, + a.identifier.name, + d.interface.identifier.name, + name, + ) + ) + + for name, template in self.attributeTemplates.items(): + if template.attr is None: + print("Template %s is unused, please remove it." % name) + + def getInterface(self, ifname): + return self.interfaces[ifname] + + def getDescriptors(self, **filters): + """Gets the descriptors that match the given filters.""" + curr = self.descriptors + # Collect up our filters, because we may have a webIDLFile filter that + # we always want to apply first. + tofilter = [(lambda x: x.interface.isExternal(), False)] + for key, val in six.iteritems(filters): + if key == "webIDLFile": + # Special-case this part to make it fast, since most of our + # getDescriptors calls are conditioned on a webIDLFile. We may + # not have this key, in which case we have no descriptors + # either. + curr = self.descriptorsByFile.get(val, []) + continue + elif key == "hasInterfaceObject": + + def getter(x): + return x.interface.hasInterfaceObject() + + elif key == "hasInterfacePrototypeObject": + + def getter(x): + return x.interface.hasInterfacePrototypeObject() + + elif key == "hasInterfaceOrInterfacePrototypeObject": + + def getter(x): + return x.hasInterfaceOrInterfacePrototypeObject() + + elif key == "isCallback": + + def getter(x): + return x.interface.isCallback() + + elif key == "isJSImplemented": + + def getter(x): + return x.interface.isJSImplemented() + + elif key == "isExposedInAnyWorker": + + def getter(x): + return x.interface.isExposedInAnyWorker() + + elif key == "isExposedInWorkerDebugger": + + def getter(x): + return x.interface.isExposedInWorkerDebugger() + + elif key == "isExposedInAnyWorklet": + + def getter(x): + return x.interface.isExposedInAnyWorklet() + + elif key == "isExposedInWindow": + + def getter(x): + return x.interface.isExposedInWindow() + + elif key == "isExposedInShadowRealms": + + def getter(x): + return x.interface.isExposedInShadowRealms() + + elif key == "isSerializable": + + def getter(x): + return x.interface.isSerializable() + + else: + # Have to watch out: just closing over "key" is not enough, + # since we're about to mutate its value + getter = (lambda attrName: lambda x: getattr(x, attrName))(key) + tofilter.append((getter, val)) + for f in tofilter: + curr = [x for x in curr if f[0](x) == f[1]] + return curr + + def getEnums(self, webIDLFile): + return [e for e in self.enums if e.filename() == webIDLFile] + + def getDictionaries(self, webIDLFile): + return [d for d in self.dictionaries if d.filename() == webIDLFile] + + def getCallbacks(self, webIDLFile): + return [c for c in self.callbacks if c.filename() == webIDLFile] + + def getDescriptor(self, interfaceName): + """ + Gets the appropriate descriptor for the given interface name. + """ + # We may have optimized out this descriptor, but the chances of anyone + # asking about it are then slim. Put the check for that _after_ we've + # done our normal lookup. But that means we have to do our normal + # lookup in a way that will not throw if it fails. + d = self.descriptorsByName.get(interfaceName, None) + if d: + return d + + raise NoSuchDescriptorError("For " + interfaceName + " found no matches") + + def getConfig(self): + return self + + def getDictionariesConvertibleToJS(self): + return [d for d in self.dictionaries if d.needsConversionToJS] + + def getDictionariesConvertibleFromJS(self): + return [d for d in self.dictionaries if d.needsConversionFromJS] + + def getDictionaryIfExists(self, dictionaryName): + return self.dictionariesByName.get(dictionaryName, None) + + +class NoSuchDescriptorError(TypeError): + def __init__(self, str): + TypeError.__init__(self, str) + + +def methodReturnsJSObject(method): + assert method.isMethod() + + for signature in method.signatures(): + returnType = signature[0] + if returnType.isObject() or returnType.isSpiderMonkeyInterface(): + return True + + return False + + +def MemberIsLegacyUnforgeable(member, descriptor): + # Note: "or" and "and" return either their LHS or RHS, not + # necessarily booleans. Make sure to return a boolean from this + # method, because callers will compare its return value to + # booleans. + return bool( + (member.isAttr() or member.isMethod()) + and not member.isStatic() + and ( + member.isLegacyUnforgeable() + or descriptor.interface.getExtendedAttribute("LegacyUnforgeable") + ) + ) + + +class Descriptor(DescriptorProvider): + """ + Represents a single descriptor for an interface. See Bindings.conf. + """ + + def __init__(self, config, interface, desc, attributeTemplates): + DescriptorProvider.__init__(self) + self.config = config + self.interface = interface + self.attributeTemplates = attributeTemplates + if self.attributeTemplates is not None: + for t in self.attributeTemplates: + t.descriptor = self + + self.wantsXrays = not interface.isExternal() and interface.isExposedInWindow() + + if self.wantsXrays: + # We could try to restrict self.wantsXrayExpandoClass further. For + # example, we could set it to false if all of our slots store + # Gecko-interface-typed things, because we don't use Xray expando + # slots for those. But note that we would need to check the types + # of not only the members of "interface" but also of all its + # ancestors, because those can have members living in our slots too. + # For now, do the simple thing. + self.wantsXrayExpandoClass = interface.totalMembersInSlots != 0 + + # Read the desc, and fill in the relevant defaults. + ifaceName = self.interface.identifier.name + # For generated iterator interfaces for other iterable interfaces, we + # just use IterableIterator as the native type, templated on the + # nativeType of the iterable interface. That way we can have a + # templated implementation for all the duplicated iterator + # functionality. + if self.interface.isIteratorInterface(): + itrName = self.interface.iterableInterface.identifier.name + itrDesc = self.getDescriptor(itrName) + nativeTypeDefault = iteratorNativeType(itrDesc) + elif self.interface.isAsyncIteratorInterface(): + itrName = self.interface.asyncIterableInterface.identifier.name + itrDesc = self.getDescriptor(itrName) + nativeTypeDefault = iteratorNativeType(itrDesc) + + elif self.interface.isExternal(): + nativeTypeDefault = "nsIDOM" + ifaceName + else: + nativeTypeDefault = "mozilla::dom::" + ifaceName + + self.nativeType = desc.get("nativeType", nativeTypeDefault) + # Now create a version of nativeType that doesn't have extra + # mozilla::dom:: at the beginning. + prettyNativeType = self.nativeType.split("::") + if prettyNativeType[0] == "mozilla": + prettyNativeType.pop(0) + if prettyNativeType[0] == "dom": + prettyNativeType.pop(0) + self.prettyNativeType = "::".join(prettyNativeType) + + self.jsImplParent = desc.get("jsImplParent", self.nativeType) + + # Do something sane for JSObject + if self.nativeType == "JSObject": + headerDefault = "js/TypeDecls.h" + elif self.interface.isCallback() or self.interface.isJSImplemented(): + # A copy of CGHeaders.getDeclarationFilename; we can't + # import it here, sadly. + # Use our local version of the header, not the exported one, so that + # test bindings, which don't export, will work correctly. + basename = os.path.basename(self.interface.filename()) + headerDefault = basename.replace(".webidl", "Binding.h") + else: + if not self.interface.isExternal() and self.interface.getExtendedAttribute( + "HeaderFile" + ): + headerDefault = self.interface.getExtendedAttribute("HeaderFile")[0] + elif ( + self.interface.isIteratorInterface() + or self.interface.isAsyncIteratorInterface() + ): + headerDefault = "mozilla/dom/IterableIterator.h" + else: + headerDefault = self.nativeType + headerDefault = headerDefault.replace("::", "/") + ".h" + self.headerFile = desc.get("headerFile", headerDefault) + self.headerIsDefault = self.headerFile == headerDefault + if self.jsImplParent == self.nativeType: + self.jsImplParentHeader = self.headerFile + else: + self.jsImplParentHeader = self.jsImplParent.replace("::", "/") + ".h" + + self.notflattened = desc.get("notflattened", False) + self.register = desc.get("register", True) + + # If we're concrete, we need to crawl our ancestor interfaces and mark + # them as having a concrete descendant. + concreteDefault = ( + not self.interface.isExternal() + and not self.interface.isCallback() + and not self.interface.isNamespace() + and + # We're going to assume that leaf interfaces are + # concrete; otherwise what's the point? Also + # interfaces with constructors had better be + # concrete; otherwise how can you construct them? + ( + not self.interface.hasChildInterfaces() + or self.interface.ctor() is not None + ) + ) + + self.concrete = desc.get("concrete", concreteDefault) + self.hasLegacyUnforgeableMembers = self.concrete and any( + MemberIsLegacyUnforgeable(m, self) for m in self.interface.members + ) + self.operations = { + "IndexedGetter": None, + "IndexedSetter": None, + "IndexedDeleter": None, + "NamedGetter": None, + "NamedSetter": None, + "NamedDeleter": None, + "Stringifier": None, + "LegacyCaller": None, + } + + self.hasDefaultToJSON = False + + # Stringifiers need to be set up whether an interface is + # concrete or not, because they're actually prototype methods and hence + # can apply to instances of descendant interfaces. Legacy callers and + # named/indexed operations only need to be set up on concrete + # interfaces, since they affect the JSClass we end up using, not the + # prototype object. + def addOperation(operation, m): + if not self.operations[operation]: + self.operations[operation] = m + + # Since stringifiers go on the prototype, we only need to worry + # about our own stringifier, not those of our ancestor interfaces. + if not self.interface.isExternal(): + for m in self.interface.members: + if m.isMethod() and m.isStringifier(): + addOperation("Stringifier", m) + if m.isMethod() and m.isDefaultToJSON(): + self.hasDefaultToJSON = True + + # We keep track of instrumente props for all non-external interfaces. + self.instrumentedProps = [] + instrumentedProps = self.interface.getExtendedAttribute("InstrumentedProps") + if instrumentedProps: + # It's actually a one-element list, with the list + # we want as the only element. + self.instrumentedProps = instrumentedProps[0] + + # Check that we don't have duplicated instrumented props. + uniqueInstrumentedProps = set(self.instrumentedProps) + if len(uniqueInstrumentedProps) != len(self.instrumentedProps): + duplicates = [ + p + for p in uniqueInstrumentedProps + if self.instrumentedProps.count(p) > 1 + ] + raise TypeError( + "Duplicated instrumented properties: %s.\n%s" + % (duplicates, self.interface.location) + ) + + if self.concrete: + self.proxy = False + iface = self.interface + for m in iface.members: + # Don't worry about inheriting legacycallers either: in + # practice these are on most-derived prototypes. + if m.isMethod() and m.isLegacycaller(): + if not m.isIdentifierLess(): + raise TypeError( + "We don't support legacycaller with " + "identifier.\n%s" % m.location + ) + if len(m.signatures()) != 1: + raise TypeError( + "We don't support overloaded " + "legacycaller.\n%s" % m.location + ) + addOperation("LegacyCaller", m) + + while iface: + for m in iface.members: + if not m.isMethod(): + continue + + def addIndexedOrNamedOperation(operation, m): + if m.isIndexed(): + operation = "Indexed" + operation + else: + assert m.isNamed() + operation = "Named" + operation + addOperation(operation, m) + + if m.isGetter(): + addIndexedOrNamedOperation("Getter", m) + if m.isSetter(): + addIndexedOrNamedOperation("Setter", m) + if m.isDeleter(): + addIndexedOrNamedOperation("Deleter", m) + if m.isLegacycaller() and iface != self.interface: + raise TypeError( + "We don't support legacycaller on " + "non-leaf interface %s.\n%s" % (iface, iface.location) + ) + + iface.setUserData("hasConcreteDescendant", True) + iface = iface.parent + + self.proxy = ( + self.supportsIndexedProperties() + or ( + self.supportsNamedProperties() and not self.hasNamedPropertiesObject + ) + or self.isMaybeCrossOriginObject() + ) + + if self.proxy: + if self.isMaybeCrossOriginObject() and ( + self.supportsIndexedProperties() or self.supportsNamedProperties() + ): + raise TypeError( + "We don't support named or indexed " + "properties on maybe-cross-origin objects. " + "This lets us assume that their proxy " + "hooks are never called via Xrays. " + "Fix %s.\n%s" % (self.interface, self.interface.location) + ) + + if not self.operations["IndexedGetter"] and ( + self.operations["IndexedSetter"] + or self.operations["IndexedDeleter"] + ): + raise SyntaxError( + "%s supports indexed properties but does " + "not have an indexed getter.\n%s" + % (self.interface, self.interface.location) + ) + if not self.operations["NamedGetter"] and ( + self.operations["NamedSetter"] or self.operations["NamedDeleter"] + ): + raise SyntaxError( + "%s supports named properties but does " + "not have a named getter.\n%s" + % (self.interface, self.interface.location) + ) + iface = self.interface + while iface: + iface.setUserData("hasProxyDescendant", True) + iface = iface.parent + + if desc.get("wantsQI", None) is not None: + self._wantsQI = desc.get("wantsQI", None) + self.wrapperCache = ( + not self.interface.isCallback() + and not self.interface.isIteratorInterface() + and not self.interface.isAsyncIteratorInterface() + and desc.get("wrapperCache", True) + ) + + self.name = interface.identifier.name + + # self.implicitJSContext is a list of names of methods and attributes + # that need a JSContext. + if self.interface.isJSImplemented(): + self.implicitJSContext = ["constructor"] + else: + self.implicitJSContext = desc.get("implicitJSContext", []) + assert isinstance(self.implicitJSContext, list) + + self._binaryNames = {} + + if not self.interface.isExternal(): + + def maybeAddBinaryName(member): + binaryName = member.getExtendedAttribute("BinaryName") + if binaryName: + assert isinstance(binaryName, list) + assert len(binaryName) == 1 + self._binaryNames.setdefault( + (member.identifier.name, member.isStatic()), binaryName[0] + ) + + for member in self.interface.members: + if not member.isAttr() and not member.isMethod(): + continue + maybeAddBinaryName(member) + + ctor = self.interface.ctor() + if ctor: + maybeAddBinaryName(ctor) + + # Some default binary names for cases when nothing else got set. + self._binaryNames.setdefault(("__legacycaller", False), "LegacyCall") + self._binaryNames.setdefault(("__stringifier", False), "Stringify") + + # Build the prototype chain. + self.prototypeChain = [] + self.needsMissingPropUseCounters = False + parent = interface + while parent: + self.needsMissingPropUseCounters = ( + self.needsMissingPropUseCounters + or parent.getExtendedAttribute("InstrumentedProps") + ) + self.prototypeChain.insert(0, parent.identifier.name) + parent = parent.parent + config.maxProtoChainLength = max( + config.maxProtoChainLength, len(self.prototypeChain) + ) + + self.hasOrdinaryObjectPrototype = desc.get("hasOrdinaryObjectPrototype", False) + + def binaryNameFor(self, name, isStatic): + return self._binaryNames.get((name, isStatic), name) + + @property + def prototypeNameChain(self): + return [self.getDescriptor(p).name for p in self.prototypeChain] + + @property + def parentPrototypeName(self): + if len(self.prototypeChain) == 1: + return None + return self.getDescriptor(self.prototypeChain[-2]).name + + def hasInterfaceOrInterfacePrototypeObject(self): + return ( + self.interface.hasInterfaceObject() + or self.interface.hasInterfacePrototypeObject() + ) + + @property + def hasNamedPropertiesObject(self): + return self.isGlobal() and self.supportsNamedProperties() + + def getExtendedAttributes(self, member, getter=False, setter=False): + def ensureValidBoolExtendedAttribute(attr, name): + if attr is not None and attr is not True: + raise TypeError("Unknown value for '%s': %s" % (name, attr[0])) + + def ensureValidThrowsExtendedAttribute(attr): + ensureValidBoolExtendedAttribute(attr, "Throws") + + def ensureValidCanOOMExtendedAttribute(attr): + ensureValidBoolExtendedAttribute(attr, "CanOOM") + + def maybeAppendNeedsErrorResultToAttrs(attrs, throws): + ensureValidThrowsExtendedAttribute(throws) + if throws is not None: + attrs.append("needsErrorResult") + + def maybeAppendCanOOMToAttrs(attrs, canOOM): + ensureValidCanOOMExtendedAttribute(canOOM) + if canOOM is not None: + attrs.append("canOOM") + + def maybeAppendNeedsSubjectPrincipalToAttrs(attrs, needsSubjectPrincipal): + if ( + needsSubjectPrincipal is not None + and needsSubjectPrincipal is not True + and needsSubjectPrincipal != ["NonSystem"] + ): + raise TypeError( + "Unknown value for 'NeedsSubjectPrincipal': %s" + % needsSubjectPrincipal[0] + ) + + if needsSubjectPrincipal is not None: + attrs.append("needsSubjectPrincipal") + if needsSubjectPrincipal == ["NonSystem"]: + attrs.append("needsNonSystemSubjectPrincipal") + + name = member.identifier.name + throws = self.interface.isJSImplemented() or member.getExtendedAttribute( + "Throws" + ) + canOOM = member.getExtendedAttribute("CanOOM") + needsSubjectPrincipal = member.getExtendedAttribute("NeedsSubjectPrincipal") + attrs = [] + if name in self.implicitJSContext: + attrs.append("implicitJSContext") + if member.isMethod(): + if self.interface.isAsyncIteratorInterface() and name == "next": + attrs.append("implicitJSContext") + # JSObject-returning [NewObject] methods must be fallible, + # since they have to (fallibly) allocate the new JSObject. + if member.getExtendedAttribute("NewObject"): + if member.returnsPromise(): + throws = True + elif methodReturnsJSObject(member): + canOOM = True + maybeAppendNeedsErrorResultToAttrs(attrs, throws) + maybeAppendCanOOMToAttrs(attrs, canOOM) + maybeAppendNeedsSubjectPrincipalToAttrs(attrs, needsSubjectPrincipal) + return attrs + + assert member.isAttr() + assert bool(getter) != bool(setter) + if throws is None: + throwsAttr = "GetterThrows" if getter else "SetterThrows" + throws = member.getExtendedAttribute(throwsAttr) + maybeAppendNeedsErrorResultToAttrs(attrs, throws) + if canOOM is None: + canOOMAttr = "GetterCanOOM" if getter else "SetterCanOOM" + canOOM = member.getExtendedAttribute(canOOMAttr) + maybeAppendCanOOMToAttrs(attrs, canOOM) + if needsSubjectPrincipal is None: + needsSubjectPrincipalAttr = ( + "GetterNeedsSubjectPrincipal" + if getter + else "SetterNeedsSubjectPrincipal" + ) + needsSubjectPrincipal = member.getExtendedAttribute( + needsSubjectPrincipalAttr + ) + maybeAppendNeedsSubjectPrincipalToAttrs(attrs, needsSubjectPrincipal) + return attrs + + def supportsIndexedProperties(self): + return self.operations["IndexedGetter"] is not None + + def lengthNeedsCallerType(self): + """ + Determine whether our length getter needs a caller type; this is needed + in some indexed-getter proxy algorithms. The idea is that if our + indexed getter needs a caller type, our automatically-generated Length() + calls need one too. + """ + assert self.supportsIndexedProperties() + indexedGetter = self.operations["IndexedGetter"] + return indexedGetter.getExtendedAttribute("NeedsCallerType") + + def supportsNamedProperties(self): + return self.operations["NamedGetter"] is not None + + def supportedNamesNeedCallerType(self): + """ + Determine whether our GetSupportedNames call needs a caller type. The + idea is that if your named getter needs a caller type, then so does + GetSupportedNames. + """ + assert self.supportsNamedProperties() + namedGetter = self.operations["NamedGetter"] + return namedGetter.getExtendedAttribute("NeedsCallerType") + + def isMaybeCrossOriginObject(self): + # If we're isGlobal and have cross-origin members, we're a Window, and + # that's not a cross-origin object. The WindowProxy is. + return ( + self.concrete + and self.interface.hasCrossOriginMembers + and not self.isGlobal() + ) + + def needsHeaderInclude(self): + """ + An interface doesn't need a header file if it is not concrete, not + pref-controlled, has no prototype object, has no static methods or + attributes and has no parent. The parent matters because we assert + things about refcounting that depend on the actual underlying type if we + have a parent. + + """ + return ( + self.interface.isExternal() + or self.concrete + or self.interface.hasInterfacePrototypeObject() + or any( + (m.isAttr() or m.isMethod()) and m.isStatic() + for m in self.interface.members + ) + or self.interface.parent + ) + + def hasThreadChecks(self): + # isExposedConditionally does not necessarily imply thread checks + # (since at least [SecureContext] is independent of them), but we're + # only used to decide whether to include nsThreadUtils.h, so we don't + # worry about that. + return ( + self.isExposedConditionally() and not self.interface.isExposedInWindow() + ) or self.interface.isExposedInSomeButNotAllWorkers() + + def hasCEReactions(self): + return any( + m.getExtendedAttribute("CEReactions") for m in self.interface.members + ) + + def isExposedConditionally(self): + return ( + self.interface.isExposedConditionally() + or self.interface.isExposedInSomeButNotAllWorkers() + ) + + def needsXrayResolveHooks(self): + """ + Generally, any interface with NeedResolve needs Xray + resolveOwnProperty and enumerateOwnProperties hooks. But for + the special case of plugin-loading elements, we do NOT want + those, because we don't want to instantiate plug-ins simply + due to chrome touching them and that's all those hooks do on + those elements. So we special-case those here. + """ + return self.interface.getExtendedAttribute( + "NeedResolve" + ) and self.interface.identifier.name not in [ + "HTMLObjectElement", + "HTMLEmbedElement", + ] + + def needsXrayNamedDeleterHook(self): + return self.operations["NamedDeleter"] is not None + + def isGlobal(self): + """ + Returns true if this is the primary interface for a global object + of some sort. + """ + return self.interface.getExtendedAttribute("Global") + + @property + def namedPropertiesEnumerable(self): + """ + Returns whether this interface should have enumerable named properties + """ + assert self.proxy + assert self.supportsNamedProperties() + iface = self.interface + while iface: + if iface.getExtendedAttribute("LegacyUnenumerableNamedProperties"): + return False + iface = iface.parent + return True + + @property + def registersGlobalNamesOnWindow(self): + return ( + self.interface.hasInterfaceObject() + and self.interface.isExposedInWindow() + and self.register + ) + + def getDescriptor(self, interfaceName): + """ + Gets the appropriate descriptor for the given interface name. + """ + return self.config.getDescriptor(interfaceName) + + def getConfig(self): + return self.config + + +# Some utility methods +def getTypesFromDescriptor(descriptor, includeArgs=True, includeReturns=True): + """ + Get argument and/or return types for all members of the descriptor. By + default returns all argument types (which includes types of writable + attributes) and all return types (which includes types of all attributes). + """ + assert includeArgs or includeReturns # Must want _something_. + members = [m for m in descriptor.interface.members] + if descriptor.interface.ctor(): + members.append(descriptor.interface.ctor()) + members.extend(descriptor.interface.legacyFactoryFunctions) + signatures = [s for m in members if m.isMethod() for s in m.signatures()] + types = [] + for s in signatures: + assert len(s) == 2 + (returnType, arguments) = s + if includeReturns: + types.append(returnType) + if includeArgs: + types.extend(a.type for a in arguments) + + types.extend( + a.type + for a in members + if (a.isAttr() and (includeReturns or (includeArgs and not a.readonly))) + ) + + if descriptor.interface.maplikeOrSetlikeOrIterable: + maplikeOrSetlikeOrIterable = descriptor.interface.maplikeOrSetlikeOrIterable + if maplikeOrSetlikeOrIterable.isMaplike(): + # The things we expand into may or may not correctly indicate in + # their formal IDL types what things we have as return values. For + # example, "keys" returns the moral equivalent of sequence<keyType> + # but just claims to return "object". Similarly, "values" returns + # the moral equivalent of sequence<valueType> but claims to return + # "object". And due to bug 1155340, "get" claims to return "any" + # instead of the right type. So let's just manually work around + # that lack of specificity. For our arguments, we already enforce + # the right types at the IDL level, so those will get picked up + # correctly. + assert maplikeOrSetlikeOrIterable.hasKeyType() + assert maplikeOrSetlikeOrIterable.hasValueType() + if includeReturns: + types.append(maplikeOrSetlikeOrIterable.keyType) + types.append(maplikeOrSetlikeOrIterable.valueType) + elif maplikeOrSetlikeOrIterable.isSetlike(): + assert maplikeOrSetlikeOrIterable.hasKeyType() + assert maplikeOrSetlikeOrIterable.hasValueType() + assert ( + maplikeOrSetlikeOrIterable.keyType + == maplikeOrSetlikeOrIterable.valueType + ) + # As in the maplike case, we don't always declare our return values + # quite correctly. + if includeReturns: + types.append(maplikeOrSetlikeOrIterable.keyType) + else: + assert ( + maplikeOrSetlikeOrIterable.isIterable() + or maplikeOrSetlikeOrIterable.isAsyncIterable() + ) + # As in the maplike/setlike cases we don't do a good job of + # declaring our actual return types, while our argument types, if + # any, are declared fine. + if includeReturns: + if maplikeOrSetlikeOrIterable.hasKeyType(): + types.append(maplikeOrSetlikeOrIterable.keyType) + if maplikeOrSetlikeOrIterable.hasValueType(): + types.append(maplikeOrSetlikeOrIterable.valueType) + + return types + + +def getTypesFromDictionary(dictionary): + """ + Get all member types for this dictionary + """ + return [m.type for m in dictionary.members] + + +def getTypesFromCallback(callback): + """ + Get the types this callback depends on: its return type and the + types of its arguments. + """ + sig = callback.signatures()[0] + types = [sig[0]] # Return type + types.extend(arg.type for arg in sig[1]) # Arguments + return types + + +def getAllTypes(descriptors, dictionaries, callbacks): + """ + Generate all the types we're dealing with. For each type, a tuple + containing type, dictionary is yielded. The dictionary can be None if the + type does not come from a dictionary. + """ + for d in descriptors: + if d.interface.isExternal(): + continue + for t in getTypesFromDescriptor(d): + yield (t, None) + for dictionary in dictionaries: + for t in getTypesFromDictionary(dictionary): + yield (t, dictionary) + for callback in callbacks: + for t in getTypesFromCallback(callback): + yield (t, callback) + + +# For sync value iterators, we use default array implementation, for async +# iterators and sync pair iterators, we use AsyncIterableIterator or +# IterableIterator instead. +def iteratorNativeType(descriptor): + assert descriptor.interface.isIterable() or descriptor.interface.isAsyncIterable() + iterableDecl = descriptor.interface.maplikeOrSetlikeOrIterable + assert iterableDecl.isPairIterator() or descriptor.interface.isAsyncIterable() + if descriptor.interface.isIterable(): + return "mozilla::dom::IterableIterator<%s>" % descriptor.nativeType + needReturnMethod = toStringBool( + descriptor.interface.maplikeOrSetlikeOrIterable.getExtendedAttribute( + "GenerateReturnMethod" + ) + is not None + ) + return "mozilla::dom::binding_detail::AsyncIterableIteratorNative<%s, %s>" % ( + descriptor.nativeType, + needReturnMethod, + ) + + +def findInnermostType(t): + """ + Find the innermost type of the given type, unwrapping Promise and Record + types, as well as everything that unroll() unwraps. + """ + while True: + if t.isRecord(): + t = t.inner + elif t.unroll() != t: + t = t.unroll() + elif t.isPromise(): + t = t.promiseInnerType() + else: + return t + + +def getDependentDictionariesFromDictionary(d): + """ + Find all the dictionaries contained in the given dictionary, as ancestors or + members. This returns a generator. + """ + while d: + yield d + for member in d.members: + for next in getDictionariesFromType(member.type): + yield next + d = d.parent + + +def getDictionariesFromType(type): + """ + Find all the dictionaries contained in type. This can be used to find + dictionaries that need conversion to JS (by looking at types that get + converted to JS) or dictionaries that need conversion from JS (by looking at + types that get converted from JS). + + This returns a generator. + """ + type = findInnermostType(type) + if type.isUnion(): + # Look for dictionaries in all the member types + for t in type.flatMemberTypes: + for next in getDictionariesFromType(t): + yield next + elif type.isDictionary(): + # Find the dictionaries that are itself, any of its ancestors, or + # contained in any of its member types. + for d in getDependentDictionariesFromDictionary(type.inner): + yield d + + +def getDictionariesConvertedToJS(descriptors, dictionaries, callbacks): + for desc in descriptors: + if desc.interface.isExternal(): + continue + + if desc.interface.isJSImplemented(): + # For a JS-implemented interface, we need to-JS + # conversions for all the types involved. + for t in getTypesFromDescriptor(desc): + for d in getDictionariesFromType(t): + yield d + elif desc.interface.isCallback(): + # For callbacks we only want to include the arguments, since that's + # where the to-JS conversion happens. + for t in getTypesFromDescriptor(desc, includeReturns=False): + for d in getDictionariesFromType(t): + yield d + else: + # For normal interfaces, we only want to include return values, + # since that's where to-JS conversion happens. + for t in getTypesFromDescriptor(desc, includeArgs=False): + for d in getDictionariesFromType(t): + yield d + + for callback in callbacks: + # We only want to look at the arguments + sig = callback.signatures()[0] + for arg in sig[1]: + for d in getDictionariesFromType(arg.type): + yield d + + for dictionary in dictionaries: + if dictionary.needsConversionToJS: + # It's explicitly flagged as needing to-JS conversion, and all its + # dependent dictionaries will need to-JS conversion too. + for d in getDependentDictionariesFromDictionary(dictionary): + yield d + + +def getDictionariesConvertedFromJS(descriptors, dictionaries, callbacks): + for desc in descriptors: + if desc.interface.isExternal(): + continue + + if desc.interface.isJSImplemented(): + # For a JS-implemented interface, we need from-JS conversions for + # all the types involved. + for t in getTypesFromDescriptor(desc): + for d in getDictionariesFromType(t): + yield d + elif desc.interface.isCallback(): + # For callbacks we only want to include the return value, since + # that's where teh from-JS conversion happens. + for t in getTypesFromDescriptor(desc, includeArgs=False): + for d in getDictionariesFromType(t): + yield d + else: + # For normal interfaces, we only want to include arguments values, + # since that's where from-JS conversion happens. + for t in getTypesFromDescriptor(desc, includeReturns=False): + for d in getDictionariesFromType(t): + yield d + + for callback in callbacks: + # We only want to look at the return value + sig = callback.signatures()[0] + for d in getDictionariesFromType(sig[0]): + yield d + + for dictionary in dictionaries: + if dictionary.needsConversionFromJS: + # It's explicitly flagged as needing from-JS conversion, and all its + # dependent dictionaries will need from-JS conversion too. + for d in getDependentDictionariesFromDictionary(dictionary): + yield d |