#!/usr/bin/env python3 # Copyright (c) 2012, the Dart project authors. Please see the AUTHORS file # for details. All rights reserved. Use of this source code is governed by a # BSD-style license that can be found in the LICENSE file. """This module provides shared functionality for systems to generate Dart APIs from the IDL database.""" import copy import json import monitored import os import re from functools import cmp_to_key from itertools import zip_longest from htmlrenamer import custom_html_constructors, html_interface_renames, \ typed_array_renames _pure_interfaces = monitored.Set('generator._pure_interfaces', [ 'AbstractWorker', 'CanvasPath', 'ChildNode', 'DocumentAnimation', 'DocumentFontFaceSet', 'DocumentFullscreen', 'DocumentXPathEvaluator', 'ElementAnimation', 'ElementFullscreen', 'EventListener', 'GlobalEventHandlers', 'ImageBitmapFactories', 'MediaQueryListListener', 'MouseEventHitRegion', 'MutationCallback', 'NavigatorCPU', 'NavigatorEvents', 'NavigatorID', 'NavigatorLanguage', 'NavigatorOnLine', 'ParentNode', 'SVGDocument', 'SVGExternalResourcesRequired', 'SVGFilterPrimitiveStandardAttributes', 'SVGFitToViewBox', 'SVGTests', 'SVGURIReference', 'SVGZoomAndPan', 'TimeoutHandler', 'URLUtils', 'URLUtilsReadOnly', 'WebGLRenderingContextBase', 'WindowBase64', 'WindowEventHandlers', 'WindowImageBitmapFactories', 'WindowPagePopup', 'WindowTimers', ]) _safe_interfaces = monitored.Set( 'generator._safe_interfaces', [ 'double', 'Float32Array', 'Float64Array', 'Int8Array', 'Int16Array', 'Int32Array', 'Uint8Array', 'Uint8ClampedArray', 'Uint16Array', 'Uint32Array', 'ArrayBufferView', 'ArrayBuffer', 'SourceBuffer', # IDL lies about this class being a pure interface. 'Console', # this one is a bit of a hack as our console implementation # in dart:html is non-standard for legacy reasons. 'AudioContext', 'AudioSourceNode', 'WebGLVertexArrayObjectOES', # Added a polyfill for this. # Types where we can get access to the prototype easily enough. # We might consider in the future treating these are regular interface types. 'StereoPannerNode', 'PannerNode', 'AudioNode', 'FontFaceSet', 'MemoryInfo', 'ConsoleBase', 'Geolocation', 'Animation', 'SourceBufferList', 'GamepadList', # The following classes are enabled just to get the build to go. # SpeechRecognitionResultList isn't really allowed but the codegen creates # invalid output otherwise. 'SpeechRecognitionResultList', 'SQLResultSetRowList', ]) # These are interfaces that we have to treat as safe for dart2js and dartium # but going in dev compiler we should not treat as safe as these classes # really aren't guaranteed to have a stable interface name. _safe_interfaces_legacy = monitored.Set('generator._safe_interfaces_legacy', [ 'ANGLEInstancedArrays', 'Bluetooth', 'Body', 'NonDocumentTypeChildNode', 'CHROMIUMSubscribeUniform', 'CHROMIUMValuebuffer', 'GeofencingRegion', 'Coordinates', 'DOMFileSystem', 'DirectoryEntry', 'DOMFileSystemSync', 'Entry', 'Database', 'DeprecatedStorageInfo', 'DeprecatedStorageQuota', 'DeviceAcceleration', 'DeviceRotationRate', 'DirectoryReader', 'EntrySync', 'DirectoryEntrySync', 'DirectoryReaderSync', 'NonElementParentNode', 'EXTBlendMinMax', 'EXTFragDepth', 'EXTShaderTextureLOD', 'EXTTextureFilterAnisotropic', 'EXTsRGB', 'EffectModel', 'FileEntry', 'FileEntrySync', 'FileWriter', 'FileWriterSync', 'FontFaceSetLoadEvent', 'Geofencing', 'Geoposition', 'Iterator', 'MediaDeviceInfo', 'MediaStreamTrackEvent', 'Metadata', 'NavigatorStorageUtils', 'StorageQuota', 'NavigatorUserMediaError', 'OESElementIndexUint', 'OESStandardDerivatives', 'OESTextureFloat', 'OESTextureFloatLinear', 'OESTextureHalfFloat', 'OESTextureHalfFloatLinear', 'OESVertexArrayObject', 'PagePopupController', 'PluginPlaceholderElement', 'PositionError', 'RTCDTMFSender', 'RTCDataChannel', 'RTCDataChannelEvent', 'RTCStatsReport', 'RTCStatsResponse', 'ReadableByteStreamReader', 'ReadableStreamReader', 'ResourceProgressEvent', 'SQLError', 'SQLResultSet', 'SQLTransaction', 'SharedArrayBuffer', 'SourceInfo', 'SpeechRecognitionAlternative', 'SpeechRecognitionResult', 'SpeechSynthesis', 'SpeechSynthesisVoice', 'StorageInfo', 'StyleMedia', 'WebGL2RenderingContextBase', 'WebGLCompressedTextureATC', 'WebGLCompressedTextureETC1', 'WebGLCompressedTexturePVRTC', 'WebGLCompressedTextureS3TC', 'WebGLDebugRendererInfo', 'WebGLDebugShaders', 'WebGLDepthTexture', 'WebGLDrawBuffers', 'WebGLLoseContext', 'WorkerConsole', 'WorkerPerformance', 'XPathNSResolver', ]) # Classes we should just suppress? # SpeechGrammarList and friends def IsPureInterface(interface_name, database): if (interface_name in _pure_interfaces): return True if (interface_name in _safe_interfaces or interface_name in _safe_interfaces_legacy or database.HasInterface(interface_name)): return False interface = database.GetInterface(interface_name) if 'Constructor' in interface.ext_attrs: return False return interface.is_no_interface_object # # Classes which have native constructors but which we are suppressing because # they are not cross-platform. # _suppressed_native_constructors = monitored.Set( 'generator._suppressed_native_constructors', [ 'DocumentFragment', 'Range', 'Text', ]) _custom_types = monitored.Set('generator._custom_types', list(typed_array_renames.keys())) def IsCustomType(interface_name): return interface_name in _custom_types _methods_with_named_formals = monitored.Set( 'generator._methods_with_named_formals', [ 'DirectoryEntry.getDirectory', 'DirectoryEntry.getFile', 'Entry.copyTo', 'Entry.moveTo', 'HTMLInputElement.setRangeText', 'HTMLTextAreaElement.setRangeText', 'XMLHttpRequest.open', ]) def hasNamedFormals(full_name): return full_name in _methods_with_named_formals def ReturnValueConversionHack(idl_type, value, interface_name): if idl_type == 'SVGMatrix': return '%sTearOff::create(%s)' % (idl_type, value) elif ((idl_type == 'SVGAngle' and interface_name != 'SVGAnimatedAngle') or (idl_type == 'SVGTransform' and interface_name == 'SVGSVGElement')): # Somewhere in the IDL it probably specifies whether we need to call # create or not. return 'SVGPropertyTearOff<%s>::create(%s)' % (idl_type, value) return value # # Renames for attributes that have names that are not legal Dart names. # _dart_attribute_renames = monitored.Dict('generator._dart_attribute_renames', { 'default': 'defaultValue', }) # # Interface version of the DOM needs to delegate typed array constructors to a # factory provider. # interface_factories = monitored.Dict('generator.interface_factories', {}) # # Custom native specs for the dart2js dom. # _dart2js_dom_custom_native_specs = monitored.Dict( 'generator._dart2js_dom_custom_native_specs', { # Nodes with different tags in different browsers can be listed as multiple # tags here provided there is not conflict in usage (e.g. browser X has tag # T and no other browser has tag T). 'AnalyserNode': 'AnalyserNode,RealtimeAnalyserNode', 'AudioContext': 'AudioContext,webkitAudioContext', 'ChannelMergerNode': 'ChannelMergerNode,AudioChannelMerger', 'ChannelSplitterNode': 'ChannelSplitterNode,AudioChannelSplitter', 'DOMRect': 'ClientRect,DOMRect', 'DOMRectList': 'ClientRectList,DOMRectList', 'CSSStyleDeclaration': # IE Firefox 'CSSStyleDeclaration,MSStyleCSSProperties,CSS2Properties', 'ApplicationCache': 'ApplicationCache,DOMApplicationCache,OfflineResourceList', 'DirectoryEntry': #Chrome Edge/Opera 'DirectoryEntry,webkitFileSystemDirectoryEntry,FileSystemDirectoryEntry', 'DirectoryReader': #Chrome Edge Opera 'DirectoryReader,WebKitDirectoryReader,webkitFileSystemDirectoryReader,FileSystemDirectoryReader', 'DOMFileSystem': #Chrome Edge Opera 'DOMFileSystem,WebKitFileSystem,webkitFileSystem,FileSystem', 'Entry': #Chrome Edge 'Entry,webkitFileSystemEntry,FileSystemEntry', 'Event': 'Event,InputEvent,SubmitEvent', # Workaround for issue 40901. 'FileEntry': #Chrome Edge 'FileEntry,webkitFileSystemFileEntry,FileSystemFileEntry', 'HTMLTableCellElement': 'HTMLTableCellElement,HTMLTableDataCellElement,HTMLTableHeaderCellElement', 'GainNode': 'GainNode,AudioGainNode', 'IDBOpenDBRequest': 'IDBOpenDBRequest,IDBVersionChangeRequest', 'MouseEvent': 'MouseEvent,DragEvent', 'MutationObserver': 'MutationObserver,WebKitMutationObserver', 'NamedNodeMap': 'NamedNodeMap,MozNamedAttrMap', 'NodeList': 'NodeList,RadioNodeList', 'OscillatorNode': 'OscillatorNode,Oscillator', 'PannerNode': 'PannerNode,AudioPannerNode,webkitAudioPannerNode', 'Position': 'Position,GeolocationPosition', 'PositionError': 'PositionError,GeolocationPositionError', 'RTCPeerConnection': 'RTCPeerConnection,webkitRTCPeerConnection,mozRTCPeerConnection', 'RTCIceCandidate': 'RTCIceCandidate,mozRTCIceCandidate', 'RTCSessionDescription': 'RTCSessionDescription,mozRTCSessionDescription', 'RTCDataChannel': 'RTCDataChannel,DataChannel', 'ScriptProcessorNode': 'ScriptProcessorNode,JavaScriptAudioNode', 'SpeechRecognition': 'SpeechRecognition,webkitSpeechRecognition', 'TransitionEvent': 'TransitionEvent,WebKitTransitionEvent', 'CSSKeyframeRule': 'CSSKeyframeRule,MozCSSKeyframeRule,WebKitCSSKeyframeRule', 'CSSKeyframesRule': 'CSSKeyframesRule,MozCSSKeyframesRule,WebKitCSSKeyframesRule', # webgl extensions are sometimes named directly after the getExtension # parameter (e.g on Firefox). 'ANGLEInstancedArrays': 'ANGLEInstancedArrays,ANGLE_instanced_arrays', 'EXTsRGB': 'EXTsRGB,EXT_sRGB', 'EXTBlendMinMax': 'EXTBlendMinMax,EXT_blend_minmax', 'EXTFragDepth': 'EXTFragDepth,EXT_frag_depth', 'EXTShaderTextureLOD': 'EXTShaderTextureLOD,EXT_shader_texture_lod', 'EXTTextureFilterAnisotropic': 'EXTTextureFilterAnisotropic,EXT_texture_filter_anisotropic', 'OESElementIndexUint': 'OESElementIndexUint,OES_element_index_uint', 'OESStandardDerivatives': 'OESStandardDerivatives,OES_standard_derivatives', 'OESTextureFloat': 'OESTextureFloat,OES_texture_float', 'OESTextureFloatLinear': 'OESTextureFloatLinear,OES_texture_float_linear', 'OESTextureHalfFloat': 'OESTextureHalfFloat,OES_texture_half_float', 'OESTextureHalfFloatLinear': 'OESTextureHalfFloatLinear,OES_texture_half_float_linear', 'OESVertexArrayObject': 'OESVertexArrayObject,OES_vertex_array_object', 'WebGLCompressedTextureATC': 'WebGLCompressedTextureATC,WEBGL_compressed_texture_atc', 'WebGLCompressedTextureETC1': 'WebGLCompressedTextureETC1,WEBGL_compressed_texture_etc1', 'WebGLCompressedTexturePVRTC': 'WebGLCompressedTexturePVRTC,WEBGL_compressed_texture_pvrtc', 'WebGLCompressedTextureS3TC': 'WebGLCompressedTextureS3TC,WEBGL_compressed_texture_s3tc', 'WebGLDebugRendererInfo': 'WebGLDebugRendererInfo,WEBGL_debug_renderer_info', 'WebGLDebugShaders': 'WebGLDebugShaders,WEBGL_debug_shaders', 'WebGLDepthTexture': 'WebGLDepthTexture,WEBGL_depth_texture', 'WebGLDrawBuffers': 'WebGLDrawBuffers,WEBGL_draw_buffers', 'WebGLLoseContext': 'WebGLLoseContext,WebGLExtensionLoseContext,WEBGL_lose_context', }, dart2jsOnly=True) def IsRegisteredType(type_name): return type_name in _idl_type_registry def MakeNativeSpec(javascript_binding_name): if javascript_binding_name in _dart2js_dom_custom_native_specs: return _dart2js_dom_custom_native_specs[javascript_binding_name] else: # Make the class 'hidden' so it is dynamically patched at runtime. This # is useful for browser compat. return javascript_binding_name def MatchSourceFilter(thing): return 'WebKit' in thing.annotations or 'Dart' in thing.annotations # Legacy Python 2 way to sort lists. Group by type, and then sort by value. class MultitypeSortKey: def __init__(self, value): self.value = value def __lt__(self, other): try: return self.value < other.value except TypeError: return str(type(self)) < str(type(other)) class ParamInfo(object): """Holder for various information about a parameter of a Dart operation. Attributes: name: Name of parameter. type_id: Original type id. None for merged types. is_optional: Parameter optionality. """ def __init__(self, name, type_id, is_optional, is_nullable, default_value, default_value_is_null): self.name = name self.type_id = type_id self.is_optional = is_optional self.is_nullable = is_nullable self.default_value = default_value self.default_value_is_null = default_value_is_null def Copy(self): return ParamInfo(self.name, self.type_id, self.is_optional, self.is_nullable, self.default_value, self.default_value_is_null) def __repr__(self): content = ('name = %s, type_id = %s, is_optional = %s, ' 'is_nullable = %s, default_value = %s, ' 'default_value_is_null %s') % ( self.name, self.type_id, self.is_optional, self.is_nullable, self.default_value, self.default_value_is_null) return '' % content def GetCallbackHandlers(interface): callback_handlers = [] callback_handlers = [ operation for operation in interface.operations if operation.id == 'handleEvent' or operation.id == 'handleMessage' ] if callback_handlers == []: callback_handlers = [ operation for operation in interface.operations if operation.id == 'handleItem' ] return callback_handlers def GetCallbackInfo(interface): """For the given interface, find operations that take callbacks (for use in auto-transforming callbacks into futures).""" callback_handlers = GetCallbackHandlers(interface) return AnalyzeOperation(interface, callback_handlers) # Given a list of overloaded arguments, render dart arguments. def _BuildArguments(args, interface, constructor=False): # TODO(srujzs): Determine if this should really be turning false instead of # argument.optional as the default. For NNBD, we'll derive parameter # nullability from argument.optional but leave optionality otherwise alone. def IsOptional(argument): if 'Callback' in argument.ext_attrs: # Optional callbacks arguments are treated as optional # arguments. return argument.optional if constructor: # FIXME: Optional constructors arguments should not be treated # as optional arguments. return argument.optional if 'DartForceOptional' in argument.ext_attrs: return True return False # Given a list of overloaded arguments, choose a suitable name. def OverloadedName(args): return '_OR_'.join(sorted(set(arg.id for arg in args))) def DartType(idl_type_name): if idl_type_name in _idl_type_registry: return _idl_type_registry[idl_type_name].dart_type or idl_type_name return idl_type_name # Given a list of overloaded arguments, choose a suitable type. def OverloadedType(args): type_ids = sorted(set(arg.type.id for arg in args)) if len(set(DartType(arg.type.id) for arg in args)) == 1: nullable = False for arg in args: # If the 'TreatNullAs' attribute exists, the param technically # is nullable. The conversion happens in the browser. nullable = nullable or getattr(arg.type, 'nullable', False) or \ 'TreatNullAs' in arg.ext_attrs return (type_ids[0], nullable) else: return (None, False) # Given a list of overloaded default values, choose a suitable one. def OverloadedDefault(args): defaults = sorted(set(arg.default_value for arg in args), key=MultitypeSortKey) if len(set(DartType(arg.type.id) for arg in args)) == 1: null_default = False for arg in args: null_default = null_default or arg.default_value_is_null return (defaults[0], null_default) else: return (None, False) result = [] is_optional = False # Process overloaded arguments across a set of overloaded operations. # Each tuple in args corresponds to overloaded arguments with the same name. for arg_tuple in list(zip_longest(*args)): is_optional = is_optional or any( arg is None or IsOptional(arg) for arg in arg_tuple) filtered = list(filter(None, arg_tuple)) (type_id, is_nullable) = OverloadedType(filtered) name = OverloadedName(filtered) (default_value, default_value_is_null) = OverloadedDefault(filtered) # For nullability determination, we'll use the arguments' optionality # instead of the IsOptional method above. optional_argument = any(arg is None or arg.optional or 'DartForceOptional' in arg.ext_attrs for arg in arg_tuple) if optional_argument and (default_value == 'Undefined' or default_value == None or default_value_is_null): is_nullable = True result.append( ParamInfo(name, type_id, is_optional, is_nullable, default_value, default_value_is_null)) return result # Argument default value is one that we suppress # FIXME(leafp) We may wish to eliminate this special treatment of optional # arguments entirely, since default values are being used more pervasively # in the IDL now. def HasSuppressedOptionalDefault(argument): return ( argument.default_value == 'Undefined') or argument.default_value_is_null def IsOptional(argument): return argument.optional and (not(HasSuppressedOptionalDefault(argument))) \ or 'DartForceOptional' in argument.ext_attrs def OperationTypeIsNullable(operation): if hasattr(operation.type, 'nullable'): if operation.type.nullable: return True if operation.type.id == 'any': # any is assumed to be nullable return True return False def AnalyzeOperation(interface, operations): """Makes operation calling convention decision for a set of overloads. Returns: An OperationInfo object. """ # split operations with optional args into multiple operations split_operations = [] for operation in operations: for i in range(0, len(operation.arguments)): if IsOptional(operation.arguments[i]): new_operation = copy.deepcopy(operation) new_operation.arguments = new_operation.arguments[:i] split_operations.append(new_operation) split_operations.append(operation) # Zip together arguments from each overload by position, then convert # to a dart argument. info = OperationInfo() info.operations = operations info.overloads = split_operations info.declared_name = operations[0].id info.name = operations[0].ext_attrs.get('DartName', info.declared_name) info.constructor_name = None info.js_name = info.declared_name info.type_name = operations[0].type.id # TODO: widen. info.type_nullable = OperationTypeIsNullable(operations[0]) info.param_infos = _BuildArguments( [op.arguments for op in split_operations], interface) full_name = '%s.%s' % (interface.id, info.declared_name) info.requires_named_arguments = full_name in _methods_with_named_formals # The arguments in that the original operation took as callbacks (for # conversion to futures). info.callback_args = [] return info def ConvertToFuture(info): """Given an OperationInfo object, convert the operation's signature so that it instead uses futures instead of callbacks.""" new_info = copy.deepcopy(info) def IsNotCallbackType(param): type_id = param.type_id if type_id is None: return False else: return 'Callback' not in type_id # Success callback is the first argument (change if this no longer holds). new_info.callback_args = list( filter(lambda x: not IsNotCallbackType(x), new_info.param_infos)) new_info.param_infos = list(filter(IsNotCallbackType, new_info.param_infos)) new_info.type_name = 'Future' return new_info def AnalyzeConstructor(interface): """Returns an OperationInfo object for the constructor. Returns None if the interface has no Constructor. """ if interface.id in _suppressed_native_constructors: return None if 'Constructor' in interface.ext_attrs: name = None overloads = interface.ext_attrs['Constructor'] idl_args = [[] if f is None else f.arguments for f in overloads] elif 'NamedConstructor' in interface.ext_attrs: func_value = interface.ext_attrs.get('NamedConstructor') idl_args = [func_value.arguments] name = func_value.id else: return None info = OperationInfo() info.overloads = None info.idl_args = idl_args info.declared_name = name info.name = name info.constructor_name = ('_' if interface.id in custom_html_constructors else None) info.js_name = name info.type_name = interface.id info.param_infos = _BuildArguments(idl_args, interface, constructor=True) info.requires_named_arguments = False info.pure_dart_constructor = False return info def IsDartListType(type): return type == 'List' or type.startswith('sequence<') def IsDartCollectionType(type): return IsDartListType(type) def FindMatchingAttribute(interface, attr1): matches = [attr2 for attr2 in interface.attributes if attr1.id == attr2.id] if matches: assert len(matches) == 1 return matches[0] return None def DartDomNameOfAttribute(attr): """Returns the Dart name for an IDLAttribute. attr.id is the 'native' or JavaScript name. To ensure uniformity, work with the true IDL name until as late a possible, e.g. translate to the Dart name when generating Dart code. """ name = attr.id name = _dart_attribute_renames.get(name, name) name = attr.ext_attrs.get('DartName', None) or name return name def TypeOrNothing(dart_type, comment=None, nullable=False): """Returns string for declaring something with |dart_type| in a context where a type may be omitted. The string is empty or has a trailing space. """ nullability_operator = '?' if nullable else '' if dart_type == 'dynamic': if comment: return '/*%s*/ ' % comment # Just a comment foo(/*T*/ x) else: return '' # foo(x) looks nicer than foo(var|dynamic x) else: return dart_type + nullability_operator + ' ' def TypeOrVar(dart_type, comment=None): """Returns string for declaring something with |dart_type| in a context where if a type is omitted, 'var' must be used instead.""" if dart_type == 'dynamic': if comment: return 'var /*%s*/' % comment # e.g. var /*T*/ x; else: return 'var' # e.g. var x; else: return dart_type class OperationInfo(object): """Holder for various derived information from a set of overloaded operations. Attributes: overloads: A list of IDL operation overloads with the same name. name: A string, the simple name of the operation. constructor_name: A string, the name of the constructor iff the constructor is named, e.g. 'fromList' in Int8Array.fromList(list). type_name: A string, the name of the return type of the operation. type_nullable: Whether or not the return type is nullable. param_infos: A list of ParamInfo. factory_parameters: A list of parameters used for custom designed Factory calls. """ def __init__(self): self.factory_parameters = None self.type_nullable = False def ParametersAsDecVarLists(self, rename_type, force_optional=False): """ Returns a tuple (required, optional, named), where: required is a list of parameter declarations corresponding to the required parameters optional is a list of parameter declarations corresponding to the optional parameters named is a boolean which is true if the optional parameters should be named A parameter declaration is a tuple (dec, var) where var is the variable name, and dec is a string suitable for declaring the variable in a parameter list. That is, dec + var is a valid parameter declaration. """ def FormatParam(param): # Is the type a typedef if so it's a union so it's dynamic. # TODO(terry): This may have to change for dart2js for code shaking the # return types (unions) needs to be emitted with @create # annotations and/or with JS('type1|type2',...) if hasattr( rename_type, '__self__') and rename_type.__self__._database.HasTypeDef( param.type_id): dart_type = 'dynamic' else: dart_type = rename_type( param.type_id) if param.type_id else 'dynamic' # Special handling for setlike IDL forEach operation. if dart_type is None and param.type_id.endswith('ForEachCallback'): dart_type = param.type_id return (TypeOrNothing(dart_type, param.type_id, param.is_nullable or param.is_optional), param.name) required = [] optional = [] for param_info in self.param_infos: if param_info.is_optional: optional.append(FormatParam(param_info)) else: if optional: raise Exception( 'Optional parameters cannot precede required ones: ' + str(param_info)) required.append(FormatParam(param_info)) needs_named = optional and self.requires_named_arguments and not force_optional return (required, optional, needs_named) def ParametersAsDecStringList(self, rename_type, force_optional=False): """Returns a list of strings where each string corresponds to a parameter declaration. All of the optional/named parameters if any will appear as a single entry at the end of the list. """ (required, optional, needs_named) = \ self.ParametersAsDecVarLists(rename_type, force_optional) def FormatParam(dec): return dec[0] + dec[1] argtexts = list(map(FormatParam, required)) if optional: left_bracket, right_bracket = '{}' if needs_named else '[]' argtexts.append(left_bracket + ', '.join(map(FormatParam, optional)) + right_bracket) return argtexts def ParametersAsDeclaration(self, rename_type, force_optional=False): p_list = self.ParametersAsDecStringList(rename_type, force_optional) return ', '.join(p_list) def NumberOfRequiredInDart(self): """ Returns a number of required arguments in Dart declaration of the operation. """ return len(list(filter(lambda i: not i.is_optional, self.param_infos))) def ParametersAsArgumentList(self, parameter_count=None, ignore_named_parameters=False): """Returns a string of the parameter names suitable for passing the parameters as arguments. """ def param_name(param_info): if self.requires_named_arguments and param_info.is_optional and not ignore_named_parameters: return '%s : %s' % (param_info.name, param_info.name) else: return param_info.name if parameter_count is None: parameter_count = len(self.param_infos) return ', '.join(map(param_name, self.param_infos[:parameter_count])) """ Check if a parameter to a Future API is a Dictionary argument and if its optional. Used for any Promised based operation to correctly convert from Map to Dictionary then perform the PromiseToFuture call. """ def dictionaryArgumentName(self, parameter_count=None): parameter_count = len(self.param_infos) for argument in self.param_infos[:parameter_count]: if argument.type_id == 'Dictionary': return [argument.name, argument.is_optional] return None def isCallback(self, type_registry, type_id): if type_id and not type_id.endswith('[]'): callback_type = type_registry._database._all_interfaces[type_id] return callback_type.operations[0].id == 'handleEvent' if len( callback_type.operations) > 0 else False else: return False def ParametersAsListOfVariables(self, parameter_count=None, type_registry=None, dart_js_interop=False, backend=None): """Returns a list of the first parameter_count parameter names as raw variables. """ isRemoveOperation = self.name == 'removeEventListener' or self.name == 'removeListener' if parameter_count is None: parameter_count = len(self.param_infos) if not type_registry: return [p.name for p in self.param_infos[:parameter_count]] else: parameters = [] for p in self.param_infos[:parameter_count]: type_id = p.type_id # Unwrap the type to get the JsObject if Type is: # # - type_id is None then it's probably a union type or overloaded # it's a dynamic/any type # - type is Object # if (wrap_unwrap_type_blink(type_id, type_registry)): type_is_callback = self.isCallback(type_registry, type_id) if (dart_js_interop and type_id == 'EventListener' and self.name in [ 'addEventListener', 'removeEventListener' ]): # Events fired need use a JSFunction not a anonymous closure to # insure the event can really be removed. parameters.append('js.allowInterop(%s)' % p.name) elif dart_js_interop and type_is_callback and not ( isRemoveOperation): # Any remove operation that has a a callback doesn't need wrapping. # TODO(terry): Kind of hacky but handles all the cases we care about callback_type = type_registry._database._all_interfaces[ type_id] callback_args_decl = [] callback_args_call = [] for callback_arg in callback_type.operations[ 0].arguments: if dart_js_interop: dart_type = '' # For non-primitives we will be passing JsObject for non-primitives, so ignore types else: dart_type = type_registry.DartType( callback_arg.type.id) + ' ' callback_args_decl.append( '%s%s' % (dart_type, callback_arg.id)) if wrap_unwrap_type_blink(callback_arg.type.id, type_registry): callback_args_call.append(callback_arg.id) else: callback_args_call.append(callback_arg.id) parameters.append( '(%s) => %s(%s)' % (", ".join(callback_args_decl), p.name, ", ".join(callback_args_call))) else: parameters.append(p.name) else: if dart_js_interop: conversion = backend._InputConversion( p.type_id, self.declared_name) passParam = p.name if conversion: # Need to pass the IDL Dictionary from Dart Map to JavaScript object. passParam = '{0}({1})'.format( conversion.function_name, p.name) else: passParam = p.name parameters.append(passParam) return parameters def ParametersAsStringOfVariables(self, parameter_count=None): """Returns a string containing the first parameter_count parameter names as raw variables, comma separated. """ return ', '.join(self.ParametersAsListOfVariables(parameter_count)) def IsStatic(self): is_static = self.overloads[0].is_static assert any([is_static == o.is_static for o in self.overloads]) return is_static def _ConstructorFullName(self, rename_type): if self.constructor_name: return rename_type(self.type_name) + '.' + self.constructor_name else: # TODO(antonm): temporary ugly hack. # While in transition phase we allow both DOM's ArrayBuffer # and dart:typed_data's ByteBuffer for IDLs' ArrayBuffers, # hence ArrayBuffer is mapped to dynamic in arguments and return # values. To compensate for that when generating ArrayBuffer itself, # we need to lie a bit: if self.type_name == 'ArrayBuffer': return 'ByteBuffer' return rename_type(self.type_name) def _ConstantOutputOrder(a, b): """Canonical output ordering for constants.""" return (a.id > b.id) - (a.id < b.id) ConstantOutputOrder = cmp_to_key(_ConstantOutputOrder) def _FormatNameList(names): """Returns JavaScript array literal expression with one name per line.""" #names = sorted(names) if len(names) <= 1: expression_string = str(names) # e.g. ['length'] else: expression_string = ',\n '.join(str(names).split(',')) expression_string = expression_string.replace('[', '[\n ') return expression_string def IndentText(text, indent): """Format lines of text with indent.""" def FormatLine(line): if line.strip(): return '%s%s\n' % (indent, line) else: return '\n' return ''.join(FormatLine(line) for line in text.split('\n')) # Given a sorted sequence of type identifiers, return an appropriate type # name def TypeName(type_ids, interface): # Dynamically type this field for now. return 'dynamic' # ------------------------------------------------------------------------------ class Conversion(object): """Represents a way of converting between types.""" def __init__(self, name, input_type, output_type, nullable_input=False, nullable_output=False): # input_type is the type of the API input (and the argument type of the # conversion function) # output_type is the type of the API output (and the result type of the # conversion function) self.function_name = name self.input_type = input_type self.output_type = output_type self.nullable_input = nullable_input or input_type == 'dynamic' self.nullable_output = nullable_output or output_type == 'dynamic' # "TYPE DIRECTION INTERFACE.MEMBER" -> conversion # Specific member of interface # "TYPE DIRECTION INTERFACE.*" -> conversion # All members of interface getting (setting) with type. # "TYPE DIRECTION" -> conversion # All getters (setters) of type. # # where DIRECTION is 'get' for getters and operation return values, 'set' for # setters and operation arguments. INTERFACE and MEMBER are the idl names. # _serialize_SSV = Conversion('convertDartToNative_SerializedScriptValue', 'dynamic', 'dynamic') dart2js_conversions = monitored.Dict( 'generator.dart2js_conversions', { # Used to convert Dart function to a JS callback typedef (old style). 'Callback set': Conversion('convertDartClosureToJS', 'dynamic', 'dynamic'), 'Date get': Conversion('convertNativeToDart_DateTime', 'dynamic', 'DateTime'), 'Date set': Conversion('convertDartToNative_DateTime', 'DateTime', 'dynamic'), # Wrap non-local Windows. We need to check EventTarget (the base type) # as well. Note, there are no functions that take a non-local Window # as a parameter / setter. 'Window get': Conversion('_convertNativeToDart_Window', 'dynamic', 'WindowBase', nullable_output=True), 'EventTarget get': Conversion('_convertNativeToDart_EventTarget', 'dynamic', 'EventTarget', nullable_output=True), 'EventTarget set': Conversion('_convertDartToNative_EventTarget', 'EventTarget', 'dynamic', nullable_input=True), 'WebGLContextAttributes get': Conversion('convertNativeToDart_ContextAttributes', 'dynamic', 'ContextAttributes'), 'ImageData get': Conversion('convertNativeToDart_ImageData', 'dynamic', 'ImageData'), 'ImageData set': Conversion('convertDartToNative_ImageData', 'ImageData', 'dynamic', nullable_input=True), 'Dictionary get': Conversion('convertNativeToDart_Dictionary', 'dynamic', 'Map', nullable_output=True), 'Dictionary set': Conversion('convertDartToNative_Dictionary', 'Map', 'dynamic', nullable_input=True), 'sequence set': Conversion('convertDartToNative_StringArray', 'List', 'List'), 'any set IDBObjectStore.add': _serialize_SSV, 'any set IDBObjectStore.put': _serialize_SSV, 'any set IDBCursor.update': _serialize_SSV, 'any get SQLResultSetRowList.item': Conversion('convertNativeToDart_Dictionary', 'dynamic', 'Map', nullable_output=True), # postMessage 'SerializedScriptValue set': _serialize_SSV, 'any set CompositorWorkerGlobalScope.postMessage': _serialize_SSV, 'any set DedicatedWorkerGlobalScope.postMessage': _serialize_SSV, 'any set MessagePort.postMessage': _serialize_SSV, 'any set Window.postMessage': _serialize_SSV, 'any set _DOMWindowCrossFrame.postMessage': _serialize_SSV, 'any set Worker.postMessage': _serialize_SSV, 'any set ServiceWorker.postMessage': _serialize_SSV, '* get CustomEvent.detail': Conversion('convertNativeToDart_SerializedScriptValue', 'dynamic', 'dynamic'), # receiving message via MessageEvent '* get MessageEvent.data': Conversion('convertNativeToDart_SerializedScriptValue', 'dynamic', 'dynamic'), # TODO(alanknight): This generates two variations for dart2js, because of # the optional argument, but not in Dartium. Should do the same for both. 'any set History.pushState': _serialize_SSV, 'any set History.replaceState': _serialize_SSV, '* get History.state': Conversion('convertNativeToDart_SerializedScriptValue', 'dynamic', 'dynamic'), '* get PopStateEvent.state': Conversion('convertNativeToDart_SerializedScriptValue', 'dynamic', 'dynamic'), # IDBAny is problematic. Some uses are just a union of other IDB types, # which need no conversion.. Others include data values which require # serialized script value processing. '* get IDBCursorWithValue.value': Conversion('_convertNativeToDart_IDBAny', 'dynamic', 'dynamic'), # This is problematic. The result property of IDBRequest is used for # all requests. Read requests like IDBDataStore.getObject need # conversion, but other requests like opening a database return # something that does not need conversion. '* get IDBRequest.result': Conversion('_convertNativeToDart_IDBAny', 'dynamic', 'dynamic'), # "source: On getting, returns the IDBObjectStore or IDBIndex that the # cursor is iterating. ...". So we should not try to convert it. '* get IDBCursor.source': None, # Should be either a DOMString, an Array of DOMStrings or null. '* get IDBObjectStore.keyPath': None, '* get XMLHttpRequest.response': Conversion('_convertNativeToDart_XHR_Response', 'dynamic', 'dynamic'), }, dart2jsOnly=True) def FindConversion(idl_type, direction, interface, member): table = dart2js_conversions return (table.get('%s %s %s.%s' % (idl_type, direction, interface, member)) or table.get('* %s %s.%s' % (direction, interface, member)) or table.get('%s %s %s.*' % (idl_type, direction, interface)) or table.get('%s %s' % (idl_type, direction))) return None # ------------------------------------------------------------------------------ class IDLTypeInfo(object): def __init__(self, idl_type, data): self._idl_type = idl_type self._data = data def idl_type(self): return self._idl_type def dart_type(self): return self._data.dart_type or self._idl_type def narrow_dart_type(self): return self.dart_type() def interface_name(self): raise NotImplementedError() def implementation_name(self): raise NotImplementedError() def has_generated_interface(self): raise NotImplementedError() def list_item_type(self): raise NotImplementedError() def merged_interface(self): return None def merged_into(self): return None def native_type(self): return self._data.native_type or self._idl_type def bindings_class(self): return 'Dart%s' % self.idl_type() def vector_to_dart_template_parameter(self): return self.native_type() def to_native_info(self, idl_node, interface_name, callback_name): cls = self.bindings_class() if 'Callback' in idl_node.ext_attrs: return '%s.release()', 'OwnPtr<%s>' % self.native_type( ), cls, 'create' # This is a hack to handle property references correctly. if (self.native_type() in [ 'SVGPropertyTearOff', 'SVGPropertyTearOff*', 'SVGMatrixTearOff' ] and (callback_name != 'createSVGTransformFromMatrixCallback' or interface_name != 'SVGTransformList')): argument_expression_template = '%s->propertyReference()' type = '%s*' % self.native_type() elif self.custom_to_native(): type = 'RefPtr<%s>' % self.native_type() argument_expression_template = '%s.get()' else: type = '%s*' % self.native_type() argument_expression_template = '%s' return argument_expression_template, type, cls, 'toNative' def pass_native_by_ref(self): return False def custom_to_native(self): return self._data.custom_to_native def parameter_type(self): return '%s*' % self.native_type() def webcore_includes(self): WTF_INCLUDES = [ 'ArrayBuffer', 'ArrayBufferView', 'Float32Array', 'Float64Array', 'Int8Array', 'Int16Array', 'Int32Array', 'Uint8Array', 'Uint8ClampedArray', 'Uint16Array', 'Uint32Array', ] if self._idl_type in WTF_INCLUDES: return ['' % self.native_type()] # TODO(vsm): Why does this need special casing? if self._idl_type == 'AnalyserNode': return ['"AnalyserNode.h"', ''] if not self._idl_type.startswith('SVG'): return ['"%s.h"' % self.native_type()] include = self._idl_type return ['"%s.h"' % include] + _svg_supplemental_includes def receiver(self): return 'receiver->' def conversion_includes(self): includes = [self._idl_type] + (self._data.conversion_includes or []) return ['"Dart%s.h"' % include for include in includes] def to_dart_conversion(self, value, interface_name=None, attributes=None): return 'Dart%s::toDart(%s)' % (self._idl_type, value) def return_to_dart_conversion(self, value, auto_dart_scope_setup, interface_name=None, attributes=None): auto_dart_scope = 'true' if auto_dart_scope_setup else 'false' return 'Dart%s::returnToDart(args, %s, %s)' % ( self._idl_type, ReturnValueConversionHack(self._idl_type, value, interface_name), auto_dart_scope) def custom_to_dart(self): return self._data.custom_to_dart class InterfaceIDLTypeInfo(IDLTypeInfo): def __init__(self, idl_type, data, dart_interface_name, type_registry): super(InterfaceIDLTypeInfo, self).__init__(idl_type, data) self._dart_interface_name = dart_interface_name self._type_registry = type_registry def dart_type(self): if self._data.dart_type: return self._data.dart_type if self.list_item_type() and not self.has_generated_interface(): item_nullable = '?' if self._data.item_type_nullable else '' return 'List<%s%s>' % (self._type_registry.TypeInfo( self._data.item_type).dart_type(), item_nullable) return self._dart_interface_name def narrow_dart_type(self): if self.list_item_type(): return self.implementation_name() # TODO(podivilov): only primitive and collection types should override # dart_type. if self._data.dart_type != None: return self.dart_type() if IsPureInterface(self.idl_type(), self._type_registry._database): return self.idl_type() return self.interface_name() def interface_name(self): return self._dart_interface_name def implementation_name(self): implementation_name = self._dart_interface_name if not self.has_generated_interface(): implementation_name = '_%s' % implementation_name return implementation_name def native_type(self): database = self._type_registry._database if database.HasInterface(self.idl_type()): interface = database.GetInterface(self.idl_type()) if 'ImplementedAs' in interface.ext_attrs: return interface.ext_attrs['ImplementedAs'] return super(InterfaceIDLTypeInfo, self).native_type() def has_generated_interface(self): return not self._data.suppress_interface def list_item_type(self): return self._data.item_type def list_item_type_nullable(self): return self._data.item_type_nullable def merged_interface(self): # All constants, attributes, and operations of merged interface should be # added to this interface. Merged idl interface does not have corresponding # Dart generated interface, and all references to merged idl interface # (e.g. parameter types, return types, parent interfaces) should be replaced # with this interface. There are two important restrictions: # 1) Merged and target interfaces shouldn't have common members, otherwise # there would be duplicated declarations in generated Dart code. # 2) Merged interface should be direct child of target interface, so the # children of merged interface are not affected by the merge. # As a consequence, target interface implementation and its direct children # interface implementations should implement merged attribute accessors and # operations. For example, SVGElement and Element implementation classes # should implement HTMLElement.insertAdjacentElement(), # HTMLElement.innerHTML, etc. return self._data.merged_interface def merged_into(self): return self._data.merged_into class CallbackIDLTypeInfo(IDLTypeInfo): def __init__(self, idl_type, data): super(CallbackIDLTypeInfo, self).__init__(idl_type, data) def interface_name(self): return self.dart_type() def implementation_name(self): return self.dart_type() def list_item_type(self): return self._data.item_type def array_type(data_type): matched = re.match(r'([\w\d_\s]+)\[\]', data_type) if not matched: return None return matched.group(1) class SequenceIDLTypeInfo(IDLTypeInfo): def __init__(self, idl_type, data, item_info): super(SequenceIDLTypeInfo, self).__init__(idl_type, data) self._item_info = item_info def dart_type(self): darttype = self._item_info.dart_type() return 'List' if darttype is None else 'List<%s>' % darttype def interface_name(self): return self.dart_type() def implementation_name(self): return self.dart_type() def vector_to_dart_template_parameter(self): raise Exception('sequences of sequences are not supported yet') def to_native_info(self, idl_node, interface_name, callback_name): item_native_type = self._item_info.vector_to_dart_template_parameter() if isinstance(self._item_info, PrimitiveIDLTypeInfo): return '%s', 'Vector<%s>' % item_native_type, 'DartUtilities', 'toNativeVector<%s>' % item_native_type return '%s', 'Vector< RefPtr<%s> >' % item_native_type, 'DartUtilities', 'toNativeVector< RefPtr<%s> >' % item_native_type def parameter_type(self): native_type = self.native_type() if array_type(native_type): return 'const Vector > &' % array_type(native_type) return native_type def pass_native_by_ref(self): return True def to_dart_conversion(self, value, interface_name=None, attributes=None): if isinstance(self._item_info, PrimitiveIDLTypeInfo): return 'DartDOMWrapper::vectorToDart(%s)' % value return 'DartDOMWrapper::vectorToDart<%s>(%s)' % ( self._item_info.bindings_class(), value) def return_to_dart_conversion(self, value, auto_dart_scope_setup=True, interface_name=None, attributes=None): return 'Dart_SetReturnValue(args, %s)' % self.to_dart_conversion( value, interface_name, attributes) def conversion_includes(self): return self._item_info.conversion_includes() class DOMStringArrayTypeInfo(SequenceIDLTypeInfo): def __init__(self, data, item_info): super(DOMStringArrayTypeInfo, self).__init__('DOMString[]', data, item_info) def to_native_info(self, idl_node, interface_name, callback_name): return '%s', 'RefPtr', 'DartDOMStringList', 'toNative' def pass_native_by_ref(self): return False def implementation_name(self): return "" class PrimitiveIDLTypeInfo(IDLTypeInfo): def __init__(self, idl_type, data): super(PrimitiveIDLTypeInfo, self).__init__(idl_type, data) def vector_to_dart_template_parameter(self): # Ugly hack. Usually IDLs floats are treated as C++ doubles, however # sequence should map to Vector if self.idl_type() == 'float': return 'float' return self.native_type() def to_native_info(self, idl_node, interface_name, callback_name): type = self.native_type() if type == 'SerializedScriptValue': type = 'RefPtr<%s>' % type if type == 'String': type = 'DartStringAdapter' target_type = self._capitalized_native_type() if self.idl_type() == 'Date': target_type = 'Date' return '%s', type, 'DartUtilities', 'dartTo%s' % target_type def parameter_type(self): if self.native_type() == 'String': return 'const String&' return self.native_type() def conversion_includes(self): return [] def to_dart_conversion(self, value, interface_name=None, attributes=None): # TODO(antonm): if there are more instances of the case # when conversion depends on both Dart type and C++ type, # consider introducing a corresponding argument/class. if self.idl_type() == 'Date': function_name = 'date' else: function_name = self._capitalized_native_type() function_name = function_name[0].lower() + function_name[1:] function_name = 'DartUtilities::%sToDart' % function_name if attributes and 'TreatReturnedNullStringAs' in attributes: function_name += 'WithNullCheck' return '%s(%s)' % (function_name, value) def return_to_dart_conversion(self, value, auto_dart_scope_setup=True, interface_name=None, attributes=None): return 'Dart_SetReturnValue(args, %s)' % self.to_dart_conversion( value, interface_name, attributes) def webcore_getter_name(self): return self._data.webcore_getter_name def webcore_setter_name(self): return self._data.webcore_setter_name def _capitalized_native_type(self): return re.sub(r'(^| )([a-z])', lambda x: x.group(2).upper(), self.native_type()) class SVGTearOffIDLTypeInfo(InterfaceIDLTypeInfo): def __init__(self, idl_type, data, interface_name, type_registry): super(SVGTearOffIDLTypeInfo, self).__init__(idl_type, data, interface_name, type_registry) def native_type(self): if self._data.native_type: return self._data.native_type tear_off_type = 'SVGPropertyTearOff' if self._idl_type.endswith('List'): tear_off_type = 'SVGListPropertyTearOff' return '%s<%s>' % (tear_off_type, self._idl_type) def receiver(self): return 'receiver->' def to_conversion_cast(self, value, interface_name, attributes): svg_primitive_types = [ 'SVGLength', 'SVGMatrix', 'SVGNumber', 'SVGPoint', 'SVGRect', 'SVGTransform' ] # This is a hack. We either need to figure out the right way to derive this # information from the IDL or remove this generator. if self.idl_type() != 'SVGTransformList': return value conversion_cast = 'static_cast<%s*>(%s)' conversion_cast = conversion_cast % (self.native_type(), value) return '%s' % (conversion_cast) def to_dart_conversion(self, value, interface_name, attributes): return 'Dart%s::toDart(%s)' % (self._idl_type, self.to_conversion_cast( value, interface_name, attributes)) def return_to_dart_conversion(self, value, auto_dart_scope_setup, interface_name, attr): auto_dart_scope = 'true' if auto_dart_scope_setup else 'false' return 'Dart%s::returnToDart(args, %s, %s)' % ( self._idl_type, self.to_conversion_cast( ReturnValueConversionHack(self._idl_type, value, interface_name), interface_name, attr), auto_dart_scope) def argument_expression(self, name, interface_name): return name class TypedListIDLTypeInfo(InterfaceIDLTypeInfo): def __init__(self, idl_type, data, interface_name, type_registry): super(TypedListIDLTypeInfo, self).__init__(idl_type, data, interface_name, type_registry) def conversion_includes(self): return ['"wtf/%s.h"' % self._idl_type] def to_dart_conversion(self, value, interface_name, attributes): return 'DartUtilities::arrayBufferViewToDart(%s)' % value def return_to_dart_conversion(self, value, auto_dart_scope_setup, interface_name, attributes): return 'Dart_SetReturnValue(args, %s)' % self.to_dart_conversion( value, interface_name, attributes) def to_native_info(self, idl_node, interface_name, callback_name): return '%s.get()', 'RefPtr<%s>' % self._idl_type, 'DartUtilities', 'dartTo%s' % self._idl_type class BasicTypedListIDLTypeInfo(InterfaceIDLTypeInfo): def __init__(self, idl_type, data, interface_name, type_registry): super(BasicTypedListIDLTypeInfo, self).__init__(idl_type, data, interface_name, type_registry) def conversion_includes(self): return [] def to_dart_conversion(self, value, interface_name, attributes): function_name = 'DartUtilities::%sToDart' % self._idl_type function_name = function_name[0].lower() + function_name[1:] return '%s(%s)' % (function_name, value) def return_to_dart_conversion(self, value, auto_dart_scope_setup, interface_name, attributes): return 'Dart_SetReturnValue(args, %s)' % self.to_dart_conversion( value, interface_name, attributes) def to_native_info(self, idl_node, interface_name, callback_name): return '%s.get()', 'RefPtr<%s>' % self._idl_type, 'DartUtilities', 'dartTo%s' % self._idl_type class TypeData(object): def __init__(self, clazz, dart_type=None, native_type=None, merged_interface=None, merged_into=None, custom_to_dart=False, custom_to_native=False, conversion_includes=None, webcore_getter_name='getAttribute', webcore_setter_name='setAttribute', item_type=None, item_type_nullable=False, suppress_interface=False): self.clazz = clazz self.dart_type = dart_type self.native_type = native_type self.merged_interface = merged_interface self.merged_into = merged_into self.custom_to_dart = custom_to_dart self.custom_to_native = custom_to_native self.conversion_includes = conversion_includes self.webcore_getter_name = webcore_getter_name self.webcore_setter_name = webcore_setter_name self.item_type = item_type self.item_type_nullable = item_type_nullable self.suppress_interface = suppress_interface def TypedListTypeData(item_type): return TypeData(clazz='TypedList', item_type=item_type) _idl_type_registry = monitored.Dict( 'generator._idl_type_registry', { 'boolean': TypeData( clazz='Primitive', dart_type='bool', native_type='bool', webcore_getter_name='hasAttribute', webcore_setter_name='setBooleanAttribute'), 'byte': TypeData(clazz='Primitive', dart_type='int', native_type='int'), 'octet': TypeData(clazz='Primitive', dart_type='int', native_type='int'), 'short': TypeData(clazz='Primitive', dart_type='int', native_type='int'), 'unsigned short': TypeData(clazz='Primitive', dart_type='int', native_type='int'), 'int': TypeData(clazz='Primitive', dart_type='int'), 'long': TypeData( clazz='Primitive', dart_type='int', native_type='int', webcore_getter_name='getIntegralAttribute', webcore_setter_name='setIntegralAttribute'), 'unsigned long': TypeData( clazz='Primitive', dart_type='int', native_type='unsigned', webcore_getter_name='getUnsignedIntegralAttribute', webcore_setter_name='setUnsignedIntegralAttribute'), 'long long': TypeData(clazz='Primitive', dart_type='int'), 'unsigned long long': TypeData(clazz='Primitive', dart_type='int'), 'float': TypeData(clazz='Primitive', dart_type='num', native_type='double'), 'double': TypeData(clazz='Primitive', dart_type='num'), 'any': TypeData( clazz='Primitive', dart_type='Object', native_type='ScriptValue'), 'Array': TypeData(clazz='Primitive', dart_type='List'), 'custom': TypeData(clazz='Primitive', dart_type='dynamic'), 'DOMRect': TypeData( clazz='Interface', dart_type='Rectangle', suppress_interface=True), 'Date': TypeData(clazz='Primitive', dart_type='DateTime', native_type='double'), 'Promise': TypeData( clazz='Primitive', dart_type='Future', native_type='ScriptPromise'), 'DOMObject': TypeData( clazz='Primitive', dart_type='Object', native_type='ScriptValue'), 'DOMString': TypeData(clazz='Primitive', dart_type='String', native_type='String'), 'ScriptURLString': TypeData(clazz='Primitive', dart_type='String', native_type='String'), # TODO(vsm): This won't actually work until we convert the Map to # a native JS Map for JS DOM. 'Dictionary': TypeData(clazz='Primitive', dart_type='Map'), 'DOMTimeStamp': TypeData( clazz='Primitive', dart_type='int', native_type='unsigned long long'), 'object': TypeData( clazz='Primitive', dart_type='Object', native_type='ScriptValue'), 'PositionOptions': TypeData(clazz='Primitive', dart_type='Object'), # TODO(sra): Come up with some meaningful name so that where this appears in # the documentation, the user is made aware that only a limited subset of # serializable types are actually permitted. 'SerializedScriptValue': TypeData(clazz='Primitive', dart_type='dynamic'), 'sequence': TypeData(clazz='Primitive', dart_type='List'), 'sequence': TypeData(clazz='Primitive', dart_type='List'), 'void': TypeData(clazz='Primitive', dart_type='void'), 'CSSRule': TypeData(clazz='Interface', conversion_includes=['CSSImportRule']), 'DOMStringMap': TypeData(clazz='Interface', dart_type='Map'), 'Window': TypeData(clazz='Interface', custom_to_dart=True), 'Element': TypeData( clazz='Interface', merged_interface='HTMLElement', custom_to_dart=True), 'EventListener': TypeData(clazz='Interface', custom_to_native=True), 'EventHandler': TypeData(clazz='Interface', custom_to_native=True), 'EventTarget': TypeData(clazz='Interface', custom_to_native=True), 'HTMLElement': TypeData(clazz='Interface', merged_into='Element', custom_to_dart=True), 'IDBAny': TypeData(clazz='Interface', dart_type='dynamic', custom_to_native=True), 'MutationRecordArray': TypeData( clazz='Interface', # C++ pass by pointer. native_type='MutationRecordArray', dart_type='List'), 'StyleSheet': TypeData(clazz='Interface', conversion_includes=['CSSStyleSheet']), 'SVGElement': TypeData(clazz='Interface', custom_to_dart=True), 'CSSRuleList': TypeData( clazz='Interface', item_type='CSSRule', suppress_interface=True), 'CSSValueList': TypeData( clazz='Interface', item_type='CSSValue', suppress_interface=True), 'MimeTypeArray': TypeData(clazz='Interface', item_type='MimeType'), 'PluginArray': TypeData(clazz='Interface', item_type='Plugin'), 'DOMRectList': TypeData( clazz='Interface', item_type='DOMRect', dart_type='List', custom_to_native=True), 'DOMStringList': TypeData( clazz='Interface', item_type='DOMString', dart_type='List', custom_to_native=True), 'FileList': TypeData(clazz='Interface', item_type='File', dart_type='List'), # Handle new FrozenArray Web IDL builtin # TODO(terry): Consider automating this mechanism to map the conversion from FrozenArray # to List. Some caveats for double, unsigned int and dictionary. 'FrozenArray': TypeData( clazz='Primitive', item_type='BackgroundFetchSettledFetch', dart_type='List'), 'FrozenArray': TypeData( clazz='Primitive', item_type='DOMString', dart_type='List', custom_to_native=True), 'FrozenArray': TypeData(clazz='Primitive', item_type='double', dart_type='List'), 'FrozenArray': TypeData(clazz='Primitive', item_type='Entry', dart_type='List'), 'FrozenArray': TypeData( clazz='Primitive', item_type='FillLightMode', dart_type='List'), 'FrozenArray': TypeData( clazz='Primitive', item_type='FontFace', dart_type='List'), 'FrozenArray': TypeData( clazz='Primitive', item_type='GamepadButton', dart_type='List'), 'FrozenArray': TypeData(clazz='Primitive', item_type='Landmark', dart_type='List'), 'FrozenArray': TypeData(clazz='Primitive', item_type='MediaImage', dart_type='List'), 'FrozenArray': TypeData( clazz='Primitive', item_type='MediaStream', dart_type='List'), 'FrozenArray': TypeData( clazz='Primitive', item_type='MessagePort', dart_type='List'), 'FrozenArray': TypeData( clazz='Primitive', item_type='NotificationAction', dart_type='List'), 'FrozenArray': TypeData( clazz='Primitive', item_type='PaymentDetailsModifier', dart_type='List'), 'FrozenArray': TypeData( clazz='Primitive', item_type='PaymentMethodData', dart_type='List'), 'FrozenArray': TypeData( clazz='Primitive', item_type='PerformanceServerTiming', dart_type='List'), 'FrozenArray': TypeData(clazz='Primitive', item_type='Point2D', dart_type='List'), 'FrozenArray': TypeData( clazz='Primitive', item_type='PresentationConnection', dart_type='List'), 'FrozenArray': TypeData( clazz='Primitive', item_type='TaskAttributionTiming', dart_type='List'), 'FrozenArray': TypeData( clazz='Primitive', item_type='unsigned long', dart_type='List'), 'FrozenArray': TypeData( clazz='Primitive', item_type='USBEndpoint', dart_type='List'), 'FrozenArray': TypeData( clazz='Primitive', item_type='USBInterface', dart_type='List'), 'FrozenArray': TypeData( clazz='Primitive', item_type='USBConfiguration', dart_type='List'), 'FrozenArray': TypeData( clazz='Primitive', item_type='USBAlternateInterface', dart_type='List'), 'FrozenArray': TypeData( clazz='Primitive', item_type='USBIsochronousInTransferPacket', dart_type='List'), 'FrozenArray': TypeData( clazz='Primitive', item_type='USBIsochronousOutTransferPacket', dart_type='List'), 'FrozenArray': TypeData( clazz='Primitive', item_type='VRStageBoundsPoint', dart_type='List'), 'Future': TypeData(clazz='Interface', dart_type='Future'), 'GamepadList': TypeData( clazz='Interface', item_type='Gamepad', item_type_nullable=True, suppress_interface=True), 'GLenum': TypeData(clazz='Primitive', dart_type='int', native_type='unsigned'), 'GLboolean': TypeData(clazz='Primitive', dart_type='bool', native_type='bool'), 'GLbitfield': TypeData(clazz='Primitive', dart_type='int', native_type='unsigned'), 'GLshort': TypeData(clazz='Primitive', dart_type='int', native_type='short'), 'GLint': TypeData(clazz='Primitive', dart_type='int', native_type='long'), 'GLsizei': TypeData(clazz='Primitive', dart_type='int', native_type='long'), 'GLintptr': TypeData(clazz='Primitive', dart_type='int'), 'GLsizeiptr': TypeData(clazz='Primitive', dart_type='int'), 'GLushort': TypeData(clazz='Primitive', dart_type='int', native_type='int'), 'GLuint': TypeData(clazz='Primitive', dart_type='int', native_type='unsigned'), 'GLfloat': TypeData(clazz='Primitive', dart_type='num', native_type='float'), 'GLclampf': TypeData(clazz='Primitive', dart_type='num', native_type='float'), 'HTMLCollection': TypeData(clazz='Interface', item_type='Node', dart_type='List'), 'NamedNodeMap': TypeData(clazz='Interface', item_type='Node'), 'NodeList': TypeData( clazz='Interface', item_type='Node', suppress_interface=False, dart_type='List'), 'NotificationAction': TypedListTypeData(''), 'SVGElementInstanceList': TypeData( clazz='Interface', item_type='SVGElementInstance', suppress_interface=True), 'SourceBufferList': TypeData(clazz='Interface', item_type='SourceBuffer'), 'SpeechGrammarList': TypeData(clazz='Interface', item_type='SpeechGrammar'), 'SpeechInputResultList': TypeData( clazz='Interface', item_type='SpeechInputResult', suppress_interface=True), 'SpeechRecognitionResultList': TypeData( clazz='Interface', item_type='SpeechRecognitionResult', suppress_interface=True), 'SQLResultSetRowList': TypeData(clazz='Interface', item_type='Dictionary'), 'StyleSheetList': TypeData( clazz='Interface', item_type='StyleSheet', suppress_interface=True), 'TextTrackCueList': TypeData(clazz='Interface', item_type='TextTrackCue'), 'TextTrackList': TypeData(clazz='Interface', item_type='TextTrack'), 'TouchList': TypeData(clazz='Interface', item_type='Touch'), 'Float32Array': TypedListTypeData('double'), 'Float64Array': TypedListTypeData('double'), 'Int8Array': TypedListTypeData('int'), 'Int16Array': TypedListTypeData('int'), 'Int32Array': TypedListTypeData('int'), 'Uint8Array': TypedListTypeData('int'), 'Uint8ClampedArray': TypedListTypeData('int'), 'Uint16Array': TypedListTypeData('int'), 'Uint32Array': TypedListTypeData('int'), 'ArrayBufferView': TypeData(clazz='BasicTypedList'), 'ArrayBuffer': TypeData(clazz='BasicTypedList'), 'SVGAngle': TypeData( clazz='SVGTearOff', native_type='SVGPropertyTearOff'), 'SVGLength': TypeData(clazz='SVGTearOff', native_type='SVGLengthTearOff'), 'SVGLengthList': TypeData( clazz='SVGTearOff', item_type='SVGLength', native_type='SVGLengthListTearOff'), 'SVGMatrix': TypeData(clazz='SVGTearOff', native_type='SVGMatrixTearOff'), 'SVGNumber': TypeData(clazz='SVGTearOff', native_type='SVGNumberTearOff'), 'SVGNumberList': TypeData( clazz='SVGTearOff', item_type='SVGNumber', native_type='SVGNumberListTearOff'), 'SVGPathSegList': TypeData( clazz='SVGTearOff', item_type='SVGPathSeg', native_type='SVGPathSegListPropertyTearOff'), 'SVGPoint': TypeData(clazz='SVGTearOff', native_type='SVGPointTearOff'), 'SVGPointList': TypeData(clazz='SVGTearOff', native_type='SVGPointListTearOff'), 'SVGPreserveAspectRatio': TypeData( clazz='SVGTearOff', native_type='SVGPreserveAspectRatioTearOff'), 'SVGRect': TypeData(clazz='SVGTearOff', native_type='SVGRectTearOff'), 'SVGStringList': TypeData( clazz='SVGTearOff', item_type='DOMString', native_type='SVGStringListTearOff'), 'SVGTransform': TypeData( clazz='SVGTearOff', native_type="SVGPropertyTearOff"), 'SVGTransformList': TypeData( clazz='SVGTearOff', item_type='SVGTransform', native_type='SVGTransformListPropertyTearOff'), # Add any setlike forEach Callback types here. 'FontFaceSetForEachCallback': TypeData(clazz='Interface', item_type='FontFaceSetForEachCallback'), }) _svg_supplemental_includes = [ '"core/svg/properties/SVGPropertyTraits.h"', ] class TypeRegistry(object): def __init__(self, database, renamer=None): self._database = database self._renamer = renamer self._cache = {} def HasInterface(self, type_name): return self._database.HasInterface(type_name) def HasTypeDef(self, type_def_name): return self._database.HasTypeDef(type_def_name) def TypeInfo(self, type_name): if not type_name in self._cache: self._cache[type_name] = self._TypeInfo(type_name) return self._cache[type_name] def DartType(self, type_name): return self.TypeInfo(type_name).dart_type() def _TypeInfo(self, type_name): match = re.match(r'(?:sequence<([\w ]+)>|(\w+)\[\])$', type_name) if match and self._database.HasDictionary(match.group(1)): interface = self._database.GetDictionary(match.group(1)) # sequence should not be List if match and match.group(1) != 'any' and not ( self._database.HasDictionary(match.group(1))): type_data = TypeData('Sequence') if self.HasTypeDef(match.group(1) or match.group(2)): # It's a typedef (union) item_info = self.TypeInfo('any') else: item_info = self.TypeInfo(match.group(1) or match.group(2)) # TODO(vsm): Generalize this code. if 'SourceInfo' in type_name: type_data.native_type = 'const Vector >& ' return SequenceIDLTypeInfo(type_name, type_data, item_info) if not type_name in _idl_type_registry: if self._database.HasEnum(type_name): return PrimitiveIDLTypeInfo( type_name, TypeData( clazz='Primitive', dart_type='String', native_type='String')) if self._database.HasInterface(type_name): interface = self._database.GetInterface(type_name) elif self._database.HasDictionary(type_name): type_data = _idl_type_registry.get('Dictionary') class_name = '%sIDLTypeInfo' % type_data.clazz return globals()[class_name](type_name, type_data) elif type_name.startswith('sequence<('): if type_name.find(' or ') != -1: # Union type of sequence is an any type (no type). type_data = TypeData('Sequence') item_info = self.TypeInfo('any') return SequenceIDLTypeInfo(type_name, type_data, item_info) elif match and self._database.HasDictionary(match.group(1)): return SequenceIDLTypeInfo(type_name, TypeData('Sequence'), self.TypeInfo(match.group(1))) elif type_name.startswith('sequence return return_type[5:-1] if isList(return_type) else return_type # TODO(jacobr): remove these obsolete methods as we don't actually # perform any wrapping. def wrap_unwrap_list_blink(return_type, type_registry): """Return True if the type is the list type is a blink know type e.g., List, List, etc.""" if isList(return_type): list_type = get_list_type(return_type) if type_registry.HasInterface(list_type): return True def wrap_unwrap_type_blink(return_type, type_registry): """Returns True if the type is a blink type that requires wrap_jso or unwrap_jso""" if return_type and return_type.startswith('Html'): return_type = return_type.replace('Html', 'HTML', 1) return (not (return_type) or return_type == 'Object' or return_type == 'dynamic') def wrap_type_blink(return_type, type_registry): """Returns True if the type is a blink type that requires wrap_jso but NOT unwrap_jso""" return (return_type == 'Map' or return_type == 'Rectangle') def wrap_return_type_blink(return_type, type_name, type_registry): """Returns True if we should wrap the returned value. This checks a number of different variations, calling the more basic functions above.""" return (wrap_unwrap_type_blink(return_type, type_registry) or wrap_unwrap_type_blink(type_name, type_registry) or wrap_type_blink(return_type, type_registry) or wrap_unwrap_list_blink(return_type, type_registry))