diff options
Diffstat (limited to 'components/script/dom')
| -rw-r--r-- | components/script/dom/bindings/codegen/parser/WebIDL.py | 608 |
1 files changed, 333 insertions, 275 deletions
diff --git a/components/script/dom/bindings/codegen/parser/WebIDL.py b/components/script/dom/bindings/codegen/parser/WebIDL.py index f210d2c6028..8bf415c269b 100644 --- a/components/script/dom/bindings/codegen/parser/WebIDL.py +++ b/components/script/dom/bindings/codegen/parser/WebIDL.py @@ -540,6 +540,9 @@ class IDLExternalInterface(IDLObjectWithIdentifier, IDLExposureMixins): def validate(self): pass + def isIteratorInterface(self): + return False + def isExternal(self): return True @@ -640,7 +643,7 @@ class IDLInterface(IDLObjectWithScope, IDLExposureMixins): self._callback = False self._finished = False self.members = [] - self.maplikeOrSetlike = None + self.maplikeOrSetlikeOrIterable = None self._partialInterfaces = [] self._extendedAttrDict = {} # namedConstructors needs deterministic ordering because bindings code @@ -664,6 +667,9 @@ class IDLInterface(IDLObjectWithScope, IDLExposureMixins): self.totalMembersInSlots = 0 # Tracking of the number of own own members we have in slots self._ownMembersInSlots = 0 + # If this is an iterator interface, we need to know what iterable + # interface we're iterating for in order to get its nativeType. + self.iterableInterface = None IDLObjectWithScope.__init__(self, location, parentScope, name) IDLExposureMixins.__init__(self, location) @@ -682,6 +688,13 @@ class IDLInterface(IDLObjectWithScope, IDLExposureMixins): except: return None + def isIterable(self): + return (self.maplikeOrSetlikeOrIterable and + self.maplikeOrSetlikeOrIterable.isIterable()) + + def isIteratorInterface(self): + return self.iterableInterface is not None + def resolveIdentifierConflict(self, scope, identifier, originalObject, newObject): assert isinstance(scope, IDLScope) assert isinstance(originalObject, IDLInterfaceMember) @@ -718,22 +731,22 @@ class IDLInterface(IDLObjectWithScope, IDLExposureMixins): # need to be treated like regular interface members, do this before # things like exposure setting. for member in self.members: - if member.isMaplikeOrSetlike(): + if member.isMaplikeOrSetlikeOrIterable(): # Check that we only have one interface declaration (currently # there can only be one maplike/setlike declaration per # interface) - if self.maplikeOrSetlike: + if self.maplikeOrSetlikeOrIterable: raise WebIDLError("%s declaration used on " "interface that already has %s " "declaration" % - (member.maplikeOrSetlikeType, - self.maplikeOrSetlike.maplikeOrSetlikeType), - [self.maplikeOrSetlike.location, + (member.maplikeOrSetlikeOrIterableType, + self.maplikeOrSetlikeOrIterable.maplikeOrSetlikeOrIterableType), + [self.maplikeOrSetlikeOrIterable.location, member.location]) - self.maplikeOrSetlike = member + self.maplikeOrSetlikeOrIterable = member # If we've got a maplike or setlike declaration, we'll be building all of # our required methods in Codegen. Generate members now. - self.maplikeOrSetlike.expand(self.members, self.isJSImplemented()) + self.maplikeOrSetlikeOrIterable.expand(self.members, self.isJSImplemented()) # Now that we've merged in our partial interfaces, set the # _exposureGlobalNames on any members that don't have it set yet. Note @@ -884,14 +897,14 @@ class IDLInterface(IDLObjectWithScope, IDLExposureMixins): # If we have a maplike or setlike, and the consequential interface # also does, throw an error. - if iface.maplikeOrSetlike and self.maplikeOrSetlike: - raise WebIDLError("Maplike/setlike interface %s cannot have " - "maplike/setlike interface %s as a " + if iface.maplikeOrSetlikeOrIterable and self.maplikeOrSetlikeOrIterable: + raise WebIDLError("Maplike/setlike/iterable interface %s cannot have " + "maplike/setlike/iterable interface %s as a " "consequential interface" % (self.identifier.name, iface.identifier.name), - [self.maplikeOrSetlike.location, - iface.maplikeOrSetlike.location]) + [self.maplikeOrSetlikeOrIterable.location, + iface.maplikeOrSetlikeOrIterable.location]) additionalMembers = iface.originalMembers for additionalMember in additionalMembers: for member in self.members: @@ -905,15 +918,15 @@ class IDLInterface(IDLObjectWithScope, IDLExposureMixins): for ancestor in self.getInheritedInterfaces(): ancestor.interfacesBasedOnSelf.add(self) - if (ancestor.maplikeOrSetlike is not None and - self.maplikeOrSetlike is not None): + if (ancestor.maplikeOrSetlikeOrIterable is not None and + self.maplikeOrSetlikeOrIterable is not None): raise WebIDLError("Cannot have maplike/setlike on %s that " "inherits %s, which is already " "maplike/setlike" % (self.identifier.name, ancestor.identifier.name), - [self.maplikeOrSetlike.location, - ancestor.maplikeOrSetlike.location]) + [self.maplikeOrSetlikeOrIterable.location, + ancestor.maplikeOrSetlikeOrIterable.location]) for ancestorConsequential in ancestor.getConsequentialInterfaces(): ancestorConsequential.interfacesBasedOnSelf.add(self) @@ -997,12 +1010,12 @@ class IDLInterface(IDLObjectWithScope, IDLExposureMixins): # At this point, we have all of our members. If the current interface # uses maplike/setlike, check for collisions anywhere in the current # interface or higher in the inheritance chain. - if self.maplikeOrSetlike: + if self.maplikeOrSetlikeOrIterable: testInterface = self isAncestor = False while testInterface: - self.maplikeOrSetlike.checkCollisions(testInterface.members, - isAncestor) + self.maplikeOrSetlikeOrIterable.checkCollisions(testInterface.members, + isAncestor) isAncestor = True testInterface = testInterface.parent @@ -1411,7 +1424,8 @@ class IDLInterface(IDLObjectWithScope, IDLExposureMixins): identifier == "AvailableIn" or identifier == "Func" or identifier == "CheckAnyPermissions" or - identifier == "CheckAllPermissions"): + identifier == "CheckAllPermissions" or + identifier == "Deprecated"): # Known extended attributes that take a string value if not attr.hasValue(): raise WebIDLError("[%s] must have a value" % identifier, @@ -1821,15 +1835,9 @@ class IDLType(IDLObject): def isSharedArrayBuffer(self): return False - def isSharedArrayBufferView(self): - return False - def isTypedArray(self): return False - def isSharedTypedArray(self): - return False - def isCallbackInterface(self): return False @@ -1850,9 +1858,7 @@ class IDLType(IDLObject): return self.isInterface() and (self.isArrayBuffer() or self.isArrayBufferView() or self.isSharedArrayBuffer() or - self.isSharedArrayBufferView() or - self.isTypedArray() or - self.isSharedTypedArray()) + self.isTypedArray()) def isDictionary(self): return False @@ -2039,15 +2045,9 @@ class IDLNullableType(IDLType): def isSharedArrayBuffer(self): return self.inner.isSharedArrayBuffer() - def isSharedArrayBufferView(self): - return self.inner.isSharedArrayBufferView() - def isTypedArray(self): return self.inner.isTypedArray() - def isSharedTypedArray(self): - return self.inner.isSharedTypedArray() - def isDictionary(self): return self.inner.isDictionary() @@ -2554,15 +2554,9 @@ class IDLTypedefType(IDLType): def isSharedArrayBuffer(self): return self.inner.isSharedArrayBuffer() - def isSharedArrayBufferView(self): - return self.inner.isSharedArrayBufferView() - def isTypedArray(self): return self.inner.isTypedArray() - def isSharedTypedArray(self): - return self.inner.isSharedTypedArray() - def isInterface(self): return self.inner.isInterface() @@ -2832,7 +2826,6 @@ class IDLBuiltinType(IDLType): 'ArrayBuffer', 'ArrayBufferView', 'SharedArrayBuffer', - 'SharedArrayBufferView', 'Int8Array', 'Uint8Array', 'Uint8ClampedArray', @@ -2841,16 +2834,7 @@ class IDLBuiltinType(IDLType): 'Int32Array', 'Uint32Array', 'Float32Array', - 'Float64Array', - 'SharedInt8Array', - 'SharedUint8Array', - 'SharedUint8ClampedArray', - 'SharedInt16Array', - 'SharedUint16Array', - 'SharedInt32Array', - 'SharedUint32Array', - 'SharedFloat32Array', - 'SharedFloat64Array' + 'Float64Array' ) TagLookup = { @@ -2877,7 +2861,6 @@ class IDLBuiltinType(IDLType): Types.ArrayBuffer: IDLType.Tags.interface, Types.ArrayBufferView: IDLType.Tags.interface, Types.SharedArrayBuffer: IDLType.Tags.interface, - Types.SharedArrayBufferView: IDLType.Tags.interface, Types.Int8Array: IDLType.Tags.interface, Types.Uint8Array: IDLType.Tags.interface, Types.Uint8ClampedArray: IDLType.Tags.interface, @@ -2886,16 +2869,7 @@ class IDLBuiltinType(IDLType): Types.Int32Array: IDLType.Tags.interface, Types.Uint32Array: IDLType.Tags.interface, Types.Float32Array: IDLType.Tags.interface, - Types.Float64Array: IDLType.Tags.interface, - Types.SharedInt8Array: IDLType.Tags.interface, - Types.SharedUint8Array: IDLType.Tags.interface, - Types.SharedUint8ClampedArray: IDLType.Tags.interface, - Types.SharedInt16Array: IDLType.Tags.interface, - Types.SharedUint16Array: IDLType.Tags.interface, - Types.SharedInt32Array: IDLType.Tags.interface, - Types.SharedUint32Array: IDLType.Tags.interface, - Types.SharedFloat32Array: IDLType.Tags.interface, - Types.SharedFloat64Array: IDLType.Tags.interface + Types.Float64Array: IDLType.Tags.interface } def __init__(self, location, name, type): @@ -2938,17 +2912,10 @@ class IDLBuiltinType(IDLType): def isSharedArrayBuffer(self): return self._typeTag == IDLBuiltinType.Types.SharedArrayBuffer - def isSharedArrayBufferView(self): - return self._typeTag == IDLBuiltinType.Types.SharedArrayBufferView - def isTypedArray(self): return (self._typeTag >= IDLBuiltinType.Types.Int8Array and self._typeTag <= IDLBuiltinType.Types.Float64Array) - def isSharedTypedArray(self): - return (self._typeTag >= IDLBuiltinType.Types.SharedInt8Array and - self._typeTag <= IDLBuiltinType.Types.SharedFloat64Array) - def isInterface(self): # TypedArray things are interface types per the TypedArray spec, # but we handle them as builtins because SpiderMonkey implements @@ -2956,9 +2923,7 @@ class IDLBuiltinType(IDLType): return (self.isArrayBuffer() or self.isArrayBufferView() or self.isSharedArrayBuffer() or - self.isSharedArrayBufferView() or - self.isTypedArray() or - self.isSharedTypedArray()) + self.isTypedArray()) def isNonCallbackInterface(self): # All the interfaces we can be are non-callback @@ -3036,15 +3001,11 @@ class IDLBuiltinType(IDLType): # that's not an ArrayBufferView or typed array. (self.isArrayBufferView() and not other.isArrayBufferView() and not other.isTypedArray()) or - (self.isSharedArrayBufferView() and not other.isSharedArrayBufferView() and - not other.isSharedTypedArray()) or # Typed arrays are distinguishable from everything # except ArrayBufferView and the same type of typed # array (self.isTypedArray() and not other.isArrayBufferView() and not - (other.isTypedArray() and other.name == self.name)) or - (self.isSharedTypedArray() and not other.isSharedArrayBufferView() and not - (other.isSharedTypedArray() and other.name == self.name))))) + (other.isTypedArray() and other.name == self.name))))) def _getDependentObjects(self): return set() @@ -3119,9 +3080,6 @@ BuiltinTypes = { IDLBuiltinType.Types.SharedArrayBuffer: IDLBuiltinType(BuiltinLocation("<builtin type>"), "SharedArrayBuffer", IDLBuiltinType.Types.SharedArrayBuffer), - IDLBuiltinType.Types.SharedArrayBufferView: - IDLBuiltinType(BuiltinLocation("<builtin type>"), "SharedArrayBufferView", - IDLBuiltinType.Types.SharedArrayBufferView), IDLBuiltinType.Types.Int8Array: IDLBuiltinType(BuiltinLocation("<builtin type>"), "Int8Array", IDLBuiltinType.Types.Int8Array), @@ -3148,34 +3106,7 @@ BuiltinTypes = { IDLBuiltinType.Types.Float32Array), IDLBuiltinType.Types.Float64Array: IDLBuiltinType(BuiltinLocation("<builtin type>"), "Float64Array", - IDLBuiltinType.Types.Float64Array), - IDLBuiltinType.Types.SharedInt8Array: - IDLBuiltinType(BuiltinLocation("<builtin type>"), "SharedInt8Array", - IDLBuiltinType.Types.SharedInt8Array), - IDLBuiltinType.Types.SharedUint8Array: - IDLBuiltinType(BuiltinLocation("<builtin type>"), "SharedUint8Array", - IDLBuiltinType.Types.SharedUint8Array), - IDLBuiltinType.Types.SharedUint8ClampedArray: - IDLBuiltinType(BuiltinLocation("<builtin type>"), "SharedUint8ClampedArray", - IDLBuiltinType.Types.SharedUint8ClampedArray), - IDLBuiltinType.Types.SharedInt16Array: - IDLBuiltinType(BuiltinLocation("<builtin type>"), "SharedInt16Array", - IDLBuiltinType.Types.SharedInt16Array), - IDLBuiltinType.Types.SharedUint16Array: - IDLBuiltinType(BuiltinLocation("<builtin type>"), "SharedUint16Array", - IDLBuiltinType.Types.SharedUint16Array), - IDLBuiltinType.Types.SharedInt32Array: - IDLBuiltinType(BuiltinLocation("<builtin type>"), "SharedInt32Array", - IDLBuiltinType.Types.SharedInt32Array), - IDLBuiltinType.Types.SharedUint32Array: - IDLBuiltinType(BuiltinLocation("<builtin type>"), "SharedUint32Array", - IDLBuiltinType.Types.SharedUint32Array), - IDLBuiltinType.Types.SharedFloat32Array: - IDLBuiltinType(BuiltinLocation("<builtin type>"), "SharedFloat32Array", - IDLBuiltinType.Types.SharedFloat32Array), - IDLBuiltinType.Types.SharedFloat64Array: - IDLBuiltinType(BuiltinLocation("<builtin type>"), "SharedFloat64Array", - IDLBuiltinType.Types.SharedFloat64Array) + IDLBuiltinType.Types.Float64Array) } @@ -3266,7 +3197,7 @@ class IDLValue(IDLObject): (self.value == float("inf") or self.value == float("-inf") or math.isnan(self.value))): raise WebIDLError("Trying to convert unrestricted value %s to non-unrestricted" - % self.value, [location]); + % self.value, [location]) return IDLValue(self.location, type, self.value) elif self.type.isString() and type.isUSVString(): # Allow USVStrings to use default value just like @@ -3366,7 +3297,8 @@ class IDLInterfaceMember(IDLObjectWithIdentifier, IDLExposureMixins): 'Const', 'Attr', 'Method', - 'MaplikeOrSetlike' + 'MaplikeOrSetlike', + 'Iterable' ) Special = enum( @@ -3392,6 +3324,10 @@ class IDLInterfaceMember(IDLObjectWithIdentifier, IDLExposureMixins): def isConst(self): return self.tag == IDLInterfaceMember.Tags.Const + def isMaplikeOrSetlikeOrIterable(self): + return (self.tag == IDLInterfaceMember.Tags.MaplikeOrSetlike or + self.tag == IDLInterfaceMember.Tags.Iterable) + def isMaplikeOrSetlike(self): return self.tag == IDLInterfaceMember.Tags.MaplikeOrSetlike @@ -3469,58 +3405,42 @@ class IDLInterfaceMember(IDLObjectWithIdentifier, IDLExposureMixins): self.aliases.append(alias) -# MaplikeOrSetlike adds a trait to an interface, like map or iteration -# functions. To handle them while still getting all of the generated binding -# code taken care of, we treat them as macros that are expanded into members -# based on parsed values. -class IDLMaplikeOrSetlike(IDLInterfaceMember): - - MaplikeOrSetlikeTypes = enum( - 'maplike', - 'setlike' - ) - - def __init__(self, location, identifier, maplikeOrSetlikeType, - readonly, keyType, valueType): - IDLInterfaceMember.__init__(self, location, identifier, - IDLInterfaceMember.Tags.MaplikeOrSetlike) +class IDLMaplikeOrSetlikeOrIterableBase(IDLInterfaceMember): + def __init__(self, location, identifier, ifaceType, keyType, valueType, ifaceKind): + IDLInterfaceMember.__init__(self, location, identifier, ifaceKind) assert isinstance(keyType, IDLType) - assert isinstance(valueType, IDLType) - self.maplikeOrSetlikeType = maplikeOrSetlikeType - self.readonly = readonly + assert ifaceType in ['maplike', 'setlike', 'iterable'] + if valueType is not None: + assert isinstance(valueType, IDLType) self.keyType = keyType self.valueType = valueType - self.slotIndex = None + self.maplikeOrSetlikeOrIterableType = ifaceType self.disallowedMemberNames = [] self.disallowedNonMethodNames = [] - # When generating JSAPI access code, we need to know the backing object - # type prefix to create the correct function. Generate here for reuse. - if self.isMaplike(): - self.prefix = 'Map' - elif self.isSetlike(): - self.prefix = 'Set' - - def __str__(self): - return "declared '%s' with key '%s'" % (self.maplikeOrSetlikeType, self.keyType) - def isMaplike(self): - return self.maplikeOrSetlikeType == "maplike" + return self.maplikeOrSetlikeOrIterableType == "maplike" def isSetlike(self): - return self.maplikeOrSetlikeType == "setlike" + return self.maplikeOrSetlikeOrIterableType == "setlike" + + def isIterable(self): + return self.maplikeOrSetlikeOrIterableType == "iterable" + + def hasValueType(self): + return self.valueType is not None def checkCollisions(self, members, isAncestor): for member in members: # Check that there are no disallowed members if (member.identifier.name in self.disallowedMemberNames and - not ((member.isMethod() and member.isMaplikeOrSetlikeMethod()) or + not ((member.isMethod() and member.isMaplikeOrSetlikeOrIterableMethod()) or (member.isAttr() and member.isMaplikeOrSetlikeAttr()))): raise WebIDLError("Member '%s' conflicts " "with reserved %s name." % (member.identifier.name, - self.maplikeOrSetlikeType), + self.maplikeOrSetlikeOrIterableType), [self.location, member.location]) # Check that there are no disallowed non-method members if (isAncestor or (member.isAttr() or member.isConst()) and @@ -3528,68 +3448,160 @@ class IDLMaplikeOrSetlike(IDLInterfaceMember): raise WebIDLError("Member '%s' conflicts " "with reserved %s method." % (member.identifier.name, - self.maplikeOrSetlikeType), + self.maplikeOrSetlikeOrIterableType), [self.location, member.location]) + def addMethod(self, name, members, allowExistingOperations, returnType, args=[], + chromeOnly=False, isPure=False, affectsNothing=False, newObject=False): + """ + Create an IDLMethod based on the parameters passed in. + + - members is the member list to add this function to, since this is + called during the member expansion portion of interface object + building. + + - chromeOnly is only True for read-only js implemented classes, to + implement underscore prefixed convenience functions which would + otherwise not be available, unlike the case of C++ bindings. + + - isPure is only True for idempotent functions, so it is not valid for + things like keys, values, etc. that return a new object every time. + + - affectsNothing means that nothing changes due to this method, which + affects JIT optimization behavior + + - newObject means the method creates and returns a new object. + + """ + # Only add name to lists for collision checks if it's not chrome + # only. + if chromeOnly: + name = "__" + name + else: + if not allowExistingOperations: + self.disallowedMemberNames.append(name) + else: + self.disallowedNonMethodNames.append(name) + # If allowExistingOperations is True, and another operation exists + # with the same name as the one we're trying to add, don't add the + # maplike/setlike operation. However, if the operation is static, + # then fail by way of creating the function, which will cause a + # naming conflict, per the spec. + if allowExistingOperations: + for m in members: + if m.identifier.name == name and m.isMethod() and not m.isStatic(): + return + method = IDLMethod(self.location, + IDLUnresolvedIdentifier(self.location, name, allowDoubleUnderscore=chromeOnly), + returnType, args, maplikeOrSetlikeOrIterable=self) + # We need to be able to throw from declaration methods + method.addExtendedAttributes( + [IDLExtendedAttribute(self.location, ("Throws",))]) + if chromeOnly: + method.addExtendedAttributes( + [IDLExtendedAttribute(self.location, ("ChromeOnly",))]) + if isPure: + method.addExtendedAttributes( + [IDLExtendedAttribute(self.location, ("Pure",))]) + # Following attributes are used for keys/values/entries. Can't mark + # them pure, since they return a new object each time they are run. + if affectsNothing: + method.addExtendedAttributes( + [IDLExtendedAttribute(self.location, ("DependsOn", "Everything")), + IDLExtendedAttribute(self.location, ("Affects", "Nothing"))]) + if newObject: + method.addExtendedAttributes( + [IDLExtendedAttribute(self.location, ("NewObject",))]) + members.append(method) + + def resolve(self, parentScope): + self.keyType.resolveType(parentScope) + if self.valueType: + self.valueType.resolveType(parentScope) + + def finish(self, scope): + IDLInterfaceMember.finish(self, scope) + if not self.keyType.isComplete(): + t = self.keyType.complete(scope) + + assert not isinstance(t, IDLUnresolvedType) + assert not isinstance(t, IDLTypedefType) + assert not isinstance(t.name, IDLUnresolvedIdentifier) + self.keyType = t + if self.valueType and not self.valueType.isComplete(): + t = self.valueType.complete(scope) + + assert not isinstance(t, IDLUnresolvedType) + assert not isinstance(t, IDLTypedefType) + assert not isinstance(t.name, IDLUnresolvedIdentifier) + self.valueType = t + + def validate(self): + IDLInterfaceMember.validate(self) + + def handleExtendedAttribute(self, attr): + IDLInterfaceMember.handleExtendedAttribute(self, attr) + + def _getDependentObjects(self): + if self.valueType: + return set([self.keyType, self.valueType]) + return set([self.keyType]) + +# Iterable adds ES6 iterator style functions and traits +# (keys/values/entries/@@iterator) to an interface. +class IDLIterable(IDLMaplikeOrSetlikeOrIterableBase): + + def __init__(self, location, identifier, keyType, valueType=None, scope=None): + IDLMaplikeOrSetlikeOrIterableBase.__init__(self, location, identifier, + "iterable", keyType, valueType, + IDLInterfaceMember.Tags.Iterable) + self.iteratorType = None + + def __str__(self): + return "declared iterable with key '%s' and value '%s'" % (self.keyType, self.valueType) + def expand(self, members, isJSImplemented): """ In order to take advantage of all of the method machinery in Codegen, we generate our functions as if they were part of the interface specification during parsing. """ - def addMethod(name, allowExistingOperations, returnType, args=[], - chromeOnly=False, isPure=False, affectsNothing=False): - """ - Create an IDLMethod based on the parameters passed in. chromeOnly is only - True for read-only js implemented classes, to implement underscore - prefixed convenience functions would otherwise not be available, - unlike the case of C++ bindings. isPure is only True for - idempotent functions, so it is not valid for things like keys, - values, etc. that return a new object every time. + # object entries() + self.addMethod("entries", members, False, self.iteratorType, + affectsNothing=True, newObject=True) + # object keys() + self.addMethod("keys", members, False, self.iteratorType, + affectsNothing=True, newObject=True) + # object values() + self.addMethod("values", members, False, self.iteratorType, + affectsNothing=True, newObject=True) - """ +# MaplikeOrSetlike adds ES6 map-or-set-like traits to an interface. +class IDLMaplikeOrSetlike(IDLMaplikeOrSetlikeOrIterableBase): - # Only add name to lists for collision checks if it's not chrome - # only. - if chromeOnly: - name = "__" + name - else: - if not allowExistingOperations: - self.disallowedMemberNames.append(name) - else: - self.disallowedNonMethodNames.append(name) - - # If allowExistingOperations is True, and another operation exists - # with the same name as the one we're trying to add, don't add the - # maplike/setlike operation. However, if the operation is static, - # then fail by way of creating the function, which will cause a - # naming conflict, per the spec. - if allowExistingOperations: - for m in members: - if m.identifier.name == name and m.isMethod() and not m.isStatic(): - return - - method = IDLMethod(self.location, - IDLUnresolvedIdentifier(self.location, name, allowDoubleUnderscore=chromeOnly), - returnType, args, maplikeOrSetlike=self) - - # We need to be able to throw from declaration methods - method.addExtendedAttributes( - [IDLExtendedAttribute(self.location, ("Throws",))]) - if chromeOnly: - method.addExtendedAttributes( - [IDLExtendedAttribute(self.location, ("ChromeOnly",))]) - if isPure: - method.addExtendedAttributes( - [IDLExtendedAttribute(self.location, ("Pure",))]) - # Following attributes are used for keys/values/entries. Can't mark - # them pure, since they return a new object each time they are run. - if affectsNothing: - method.addExtendedAttributes( - [IDLExtendedAttribute(self.location, ("DependsOn", "Everything")), - IDLExtendedAttribute(self.location, ("Affects", "Nothing"))]) - members.append(method) + def __init__(self, location, identifier, maplikeOrSetlikeType, + readonly, keyType, valueType): + IDLMaplikeOrSetlikeOrIterableBase.__init__(self, location, identifier, maplikeOrSetlikeType, + keyType, valueType, IDLInterfaceMember.Tags.MaplikeOrSetlike) + self.readonly = readonly + self.slotIndex = None + + # When generating JSAPI access code, we need to know the backing object + # type prefix to create the correct function. Generate here for reuse. + if self.isMaplike(): + self.prefix = 'Map' + elif self.isSetlike(): + self.prefix = 'Set' + + def __str__(self): + return "declared '%s' with key '%s'" % (self.maplikeOrSetlikeOrIterableType, self.keyType) + def expand(self, members, isJSImplemented): + """ + In order to take advantage of all of the method machinery in Codegen, + we generate our functions as if they were part of the interface + specification during parsing. + """ # Both maplike and setlike have a size attribute members.append(IDLAttribute(self.location, IDLUnresolvedIdentifier(BuiltinLocation("<auto-generated-identifier>"), "size"), @@ -3599,14 +3611,14 @@ class IDLMaplikeOrSetlike(IDLInterfaceMember): self.reserved_ro_names = ["size"] # object entries() - addMethod("entries", False, BuiltinTypes[IDLBuiltinType.Types.object], - affectsNothing=True) + self.addMethod("entries", members, False, BuiltinTypes[IDLBuiltinType.Types.object], + affectsNothing=True) # object keys() - addMethod("keys", False, BuiltinTypes[IDLBuiltinType.Types.object], - affectsNothing=True) + self.addMethod("keys", members, False, BuiltinTypes[IDLBuiltinType.Types.object], + affectsNothing=True) # object values() - addMethod("values", False, BuiltinTypes[IDLBuiltinType.Types.object], - affectsNothing=True) + self.addMethod("values", members, False, BuiltinTypes[IDLBuiltinType.Types.object], + affectsNothing=True) # void forEach(callback(valueType, keyType), thisVal) foreachArguments = [IDLArgument(self.location, @@ -3618,8 +3630,8 @@ class IDLMaplikeOrSetlike(IDLInterfaceMember): "thisArg"), BuiltinTypes[IDLBuiltinType.Types.any], optional=True)] - addMethod("forEach", False, BuiltinTypes[IDLBuiltinType.Types.void], - foreachArguments) + self.addMethod("forEach", members, False, BuiltinTypes[IDLBuiltinType.Types.void], + foreachArguments) def getKeyArg(): return IDLArgument(self.location, @@ -3627,39 +3639,39 @@ class IDLMaplikeOrSetlike(IDLInterfaceMember): self.keyType) # boolean has(keyType key) - addMethod("has", False, BuiltinTypes[IDLBuiltinType.Types.boolean], - [getKeyArg()], isPure=True) + self.addMethod("has", members, False, BuiltinTypes[IDLBuiltinType.Types.boolean], + [getKeyArg()], isPure=True) if not self.readonly: # void clear() - addMethod("clear", True, BuiltinTypes[IDLBuiltinType.Types.void], - []) + self.addMethod("clear", members, True, BuiltinTypes[IDLBuiltinType.Types.void], + []) # boolean delete(keyType key) - addMethod("delete", True, - BuiltinTypes[IDLBuiltinType.Types.boolean], [getKeyArg()]) + self.addMethod("delete", members, True, + BuiltinTypes[IDLBuiltinType.Types.boolean], [getKeyArg()]) # Always generate underscored functions (e.g. __add, __clear) for js # implemented interfaces as convenience functions. if isJSImplemented: # void clear() - addMethod("clear", True, BuiltinTypes[IDLBuiltinType.Types.void], - [], chromeOnly=True) + self.addMethod("clear", members, True, BuiltinTypes[IDLBuiltinType.Types.void], + [], chromeOnly=True) # boolean delete(keyType key) - addMethod("delete", True, - BuiltinTypes[IDLBuiltinType.Types.boolean], [getKeyArg()], - chromeOnly=True) + self.addMethod("delete", members, True, + BuiltinTypes[IDLBuiltinType.Types.boolean], [getKeyArg()], + chromeOnly=True) if self.isSetlike(): if not self.readonly: # Add returns the set object it just added to. # object add(keyType key) - addMethod("add", True, - BuiltinTypes[IDLBuiltinType.Types.object], [getKeyArg()]) + self.addMethod("add", members, True, + BuiltinTypes[IDLBuiltinType.Types.object], [getKeyArg()]) if isJSImplemented: - addMethod("add", True, - BuiltinTypes[IDLBuiltinType.Types.object], [getKeyArg()], - chromeOnly=True) + self.addMethod("add", members, True, + BuiltinTypes[IDLBuiltinType.Types.object], [getKeyArg()], + chromeOnly=True) return # If we get this far, we're a maplike declaration. @@ -3672,8 +3684,8 @@ class IDLMaplikeOrSetlike(IDLInterfaceMember): # # TODO: Bug 1155340 may change this to use specific type to provide # more info to JIT. - addMethod("get", False, BuiltinTypes[IDLBuiltinType.Types.any], - [getKeyArg()], isPure=True) + self.addMethod("get", members, False, BuiltinTypes[IDLBuiltinType.Types.any], + [getKeyArg()], isPure=True) def getValueArg(): return IDLArgument(self.location, @@ -3681,42 +3693,11 @@ class IDLMaplikeOrSetlike(IDLInterfaceMember): self.valueType) if not self.readonly: - addMethod("set", True, BuiltinTypes[IDLBuiltinType.Types.object], - [getKeyArg(), getValueArg()]) + self.addMethod("set", members, True, BuiltinTypes[IDLBuiltinType.Types.object], + [getKeyArg(), getValueArg()]) if isJSImplemented: - addMethod("set", True, BuiltinTypes[IDLBuiltinType.Types.object], - [getKeyArg(), getValueArg()], chromeOnly=True) - - def resolve(self, parentScope): - self.keyType.resolveType(parentScope) - self.valueType.resolveType(parentScope) - - def finish(self, scope): - IDLInterfaceMember.finish(self, scope) - if not self.keyType.isComplete(): - t = self.keyType.complete(scope) - - assert not isinstance(t, IDLUnresolvedType) - assert not isinstance(t, IDLTypedefType) - assert not isinstance(t.name, IDLUnresolvedIdentifier) - self.keyType = t - if not self.valueType.isComplete(): - t = self.valueType.complete(scope) - - assert not isinstance(t, IDLUnresolvedType) - assert not isinstance(t, IDLTypedefType) - assert not isinstance(t.name, IDLUnresolvedIdentifier) - self.valueType = t - - def validate(self): - IDLInterfaceMember.validate(self) - - def handleExtendedAttribute(self, attr): - IDLInterfaceMember.handleExtendedAttribute(self, attr) - - def _getDependentObjects(self): - return set([self.keyType, self.valueType]) - + self.addMethod("set", members, True, BuiltinTypes[IDLBuiltinType.Types.object], + [getKeyArg(), getValueArg()], chromeOnly=True) class IDLConst(IDLInterfaceMember): def __init__(self, location, identifier, type, value): @@ -4026,6 +4007,11 @@ class IDLAttribute(IDLInterfaceMember): "readonly attributes" % attr.value(), [attr.location, self.location]) self._setDependsOn(attr.value()) + elif identifier == "UseCounter": + if self.stringifier: + raise WebIDLError("[UseCounter] must not be used on a " + "stringifier attribute", + [attr.location, self.location]) elif (identifier == "Pref" or identifier == "Deprecated" or identifier == "SetterThrows" or @@ -4313,7 +4299,7 @@ class IDLMethod(IDLInterfaceMember, IDLScope): static=False, getter=False, setter=False, creator=False, deleter=False, specialType=NamedOrIndexed.Neither, legacycaller=False, stringifier=False, jsonifier=False, - maplikeOrSetlike=None): + maplikeOrSetlikeOrIterable=None): # REVIEW: specialType is NamedOrIndexed -- wow, this is messed up. IDLInterfaceMember.__init__(self, location, identifier, IDLInterfaceMember.Tags.Method) @@ -4341,8 +4327,8 @@ class IDLMethod(IDLInterfaceMember, IDLScope): self._stringifier = stringifier assert isinstance(jsonifier, bool) self._jsonifier = jsonifier - assert maplikeOrSetlike is None or isinstance(maplikeOrSetlike, IDLMaplikeOrSetlike) - self.maplikeOrSetlike = maplikeOrSetlike + assert maplikeOrSetlikeOrIterable is None or isinstance(maplikeOrSetlikeOrIterable, IDLMaplikeOrSetlikeOrIterableBase) + self.maplikeOrSetlikeOrIterable = maplikeOrSetlikeOrIterable self._specialType = specialType self._unforgeable = False self.dependsOn = "Everything" @@ -4424,12 +4410,21 @@ class IDLMethod(IDLInterfaceMember, IDLScope): def isJsonifier(self): return self._jsonifier - def isMaplikeOrSetlikeMethod(self): + def isMaplikeOrSetlikeOrIterableMethod(self): """ True if this method was generated as part of a maplike/setlike/etc interface (e.g. has/get methods) """ - return self.maplikeOrSetlike is not None + return self.maplikeOrSetlikeOrIterable is not None + + def isSpecial(self): + return (self.isGetter() or + self.isSetter() or + self.isCreator() or + self.isDeleter() or + self.isLegacycaller() or + self.isStringifier() or + self.isJsonifier()) def hasOverloads(self): return self._hasOverloads @@ -4443,7 +4438,7 @@ class IDLMethod(IDLInterfaceMember, IDLScope): an non-identifier name, they actually DO have an identifier. """ return (self.identifier.name[:2] == "__" and - not self.isMaplikeOrSetlikeMethod()) + not self.isMaplikeOrSetlikeOrIterableMethod()) def resolve(self, parentScope): assert isinstance(parentScope, IDLScope) @@ -4712,6 +4707,11 @@ class IDLMethod(IDLInterfaceMember, IDLScope): raise WebIDLError("[Alias] takes an identifier or string", [attr.location]) self._addAlias(attr.value()) + elif identifier == "UseCounter": + if self.isSpecial(): + raise WebIDLError("[UseCounter] must not be used on a special " + "operation", + [attr.location, self.location]) elif (identifier == "Throws" or identifier == "NewObject" or identifier == "ChromeOnly" or @@ -4723,7 +4723,6 @@ class IDLMethod(IDLInterfaceMember, IDLScope): identifier == "CheckAnyPermissions" or identifier == "CheckAllPermissions" or identifier == "BinaryName" or - identifier == "MethodIdentityTestable" or identifier == "StaticClassOverride"): # Known attributes that we don't need to do anything with here pass @@ -4946,7 +4945,8 @@ class Tokenizer(object): "SharedArrayBuffer": "SHAREDARRAYBUFFER", "or": "OR", "maplike": "MAPLIKE", - "setlike": "SETLIKE" + "setlike": "SETLIKE", + "iterable": "ITERABLE" } tokens.extend(keywords.values()) @@ -5100,8 +5100,9 @@ class Parser(Tokenizer): raise ex pass - p[0] = IDLInterface(location, self.globalScope(), identifier, parent, + iface = IDLInterface(location, self.globalScope(), identifier, parent, members, isKnownNonPartial=True) + p[0] = iface def p_InterfaceForwardDecl(self, p): """ @@ -5187,7 +5188,7 @@ class Parser(Tokenizer): def p_InterfaceMember(self, p): """ InterfaceMember : Const - | AttributeOrOperationOrMaplikeOrSetlike + | AttributeOrOperationOrMaplikeOrSetlikeOrIterable """ p[0] = p[1] @@ -5402,15 +5403,30 @@ class Parser(Tokenizer): """ p[0] = False - def p_AttributeOrOperationOrMaplikeOrSetlike(self, p): + def p_AttributeOrOperationOrMaplikeOrSetlikeOrIterable(self, p): """ - AttributeOrOperationOrMaplikeOrSetlike : Attribute - | Maplike - | Setlike - | Operation + AttributeOrOperationOrMaplikeOrSetlikeOrIterable : Attribute + | Maplike + | Setlike + | Iterable + | Operation """ p[0] = p[1] + def p_Iterable(self, p): + """ + Iterable : ITERABLE LT Type GT SEMICOLON + | ITERABLE LT Type COMMA Type GT SEMICOLON + """ + location = self.getLocation(p, 2) + identifier = IDLUnresolvedIdentifier(location, "__iterable", + allowDoubleUnderscore=True) + keyType = p[3] + valueType = None + if (len(p) > 6): + valueType = p[5] + p[0] = IDLIterable(location, identifier, keyType, valueType, self.globalScope()) + def p_Setlike(self, p): """ Setlike : ReadOnly SETLIKE LT Type GT SEMICOLON @@ -5783,6 +5799,7 @@ class Parser(Tokenizer): | IMPLEMENTS | INHERIT | INTERFACE + | ITERABLE | LEGACYCALLER | MAPLIKE | PARTIAL @@ -6432,7 +6449,7 @@ class Parser(Tokenizer): assert isinstance(scope, IDLScope) # xrange omits the last value. - for x in xrange(IDLBuiltinType.Types.ArrayBuffer, IDLBuiltinType.Types.SharedFloat64Array + 1): + for x in xrange(IDLBuiltinType.Types.ArrayBuffer, IDLBuiltinType.Types.Float64Array + 1): builtin = BuiltinTypes[x] name = builtin.name typedef = IDLTypedef(BuiltinLocation("<builtin type>"), scope, builtin, name) @@ -6461,7 +6478,49 @@ class Parser(Tokenizer): self._filename = None def finish(self): - # First, finish all the IDLImplementsStatements. In particular, we + # If we have interfaces that are iterable, create their + # iterator interfaces and add them to the productions array. + interfaceStatements = [p for p in self._productions if + isinstance(p, IDLInterface)] + + iterableIteratorIface = None + for iface in interfaceStatements: + iterable = None + # We haven't run finish() on the interface yet, so we don't know + # whether our interface is maplike/setlike/iterable or not. This + # means we have to loop through the members to see if we have an + # iterable member. + for m in iface.members: + if isinstance(m, IDLIterable): + iterable = m + break + if iterable: + def simpleExtendedAttr(str): + return IDLExtendedAttribute(iface.location, (str, )) + nextMethod = IDLMethod( + iface.location, + IDLUnresolvedIdentifier(iface.location, "next"), + BuiltinTypes[IDLBuiltinType.Types.object], []) + nextMethod.addExtendedAttributes([simpleExtendedAttr("Throws")]) + itr_ident = IDLUnresolvedIdentifier(iface.location, + iface.identifier.name + "Iterator") + itr_iface = IDLInterface(iface.location, self.globalScope(), + itr_ident, None, [nextMethod], + isKnownNonPartial=True) + itr_iface.addExtendedAttributes([simpleExtendedAttr("NoInterfaceObject")]) + # Make sure the exposure set for the iterator interface is the + # same as the exposure set for the iterable interface, because + # we're going to generate methods on the iterable that return + # instances of the iterator. + itr_iface._exposureGlobalNames = set(iface._exposureGlobalNames) + # Always append generated iterable interfaces after the + # interface they're a member of, otherwise nativeType generation + # won't work correctly. + itr_iface.iterableInterface = iface + self._productions.append(itr_iface) + iterable.iteratorType = IDLWrapperType(iface.location, itr_iface) + + # Then, finish all the IDLImplementsStatements. In particular, we # have to make sure we do those before we do the IDLInterfaces. # XXX khuey hates this bit and wants to nuke it from orbit. implementsStatements = [p for p in self._productions if @@ -6493,7 +6552,6 @@ class Parser(Tokenizer): _builtins = """ typedef unsigned long long DOMTimeStamp; typedef (ArrayBufferView or ArrayBuffer) BufferSource; - typedef (SharedArrayBufferView or SharedArrayBuffer) SharedBufferSource; """ |