Inheritance diagram for scripts.systemhtml.Dart2JSBackend:

Public Member Functions
def	__init__ (self, interface, options, logging_level=logging.WARNING, generate_static_extensions=False)

def	ImplementsMergedMembers (self)

def	GenerateCallback (self, info)

def	AdditionalImplementedInterfaces (self)

def	NativeSpec (self)

def	ImplementationTemplate (self)

def	StartInterface (self, members_emitter)

def	FinishInterface (self)

def	HasSupportCheck (self)

def	GetSupportCheck (self)

def	GenerateCustomFactory (self, constructor_info)

def	MakeFactoryCall (self, factory, method, arguments, constructor_info)

def	IsConstructorArgumentOptional (self, argument)

def	EmitStaticFactoryOverload (self, constructor_info, name, arguments, emitter)

def	SecondaryContext (self, interface)

def	HasIndexedGetter (self)

def	AddIndexer (self, element_type, nullable)

def	EmitAttribute (self, attribute, html_name, read_only)

def	AmendIndexer (self, element_type)

def	RootClassName (self)

def	OmitOperationOverrides (self)

def	EmitOperation (self, info, html_name, dart_js_interop=False)

def	CustomJSMembers (self)

Public Member Functions inherited from scripts.htmldartgenerator.HtmlDartGenerator
def	__init__ (self, interface, options, dart_use_blink, logger)

def	EmitSupportCheck (self)

def	EmitEventGetter (self, events_class_name)

def	AddMembers (self, interface, declare_only=False, dart_js_interop=False)

def	AddSecondaryMembers (self, interface)

def	OmitOperationOverrides (self)

def	AddConstant (self, constant)

def	AddAttribute (self, attribute, declare_only=False)

def	AddOperation (self, info, declare_only=False, dart_js_interop=False)

def	AdditionalImplementedInterfaces (self)

def	Mixins (self)

def	AddConstructors (self, constructors, factory_name, factory_constructor_name, constructor_emitter)

def	EmitHelpers (self, base_class, members_emitter)

def	DeclareAttribute (self, attribute, attr_name, read_only)

def	DeclareOperation (self, operation, return_type_name, method_name)

def	EmitListMixin (self, element_name, nullable)

def	SecureOutputType (self, type_name, is_dart_type=False, can_narrow_type=False, nullable=False)

def	SecureBaseName (self, type_name)

def	is_DOM_type (self, type_name)

Detailed Description

Generates a dart2js class for the dart:html library from a DOM IDL
interface.

Definition at line 1273 of file systemhtml.py.

Constructor & Destructor Documentation

◆ init()

def scripts.systemhtml.Dart2JSBackend.__init__	(	self,
		interface,
		options,
		logging_level = `logging.WARNING`,
		generate_static_extensions = `False`
	)

Reimplemented from scripts.htmldartgenerator.HtmlDartGenerator.

Definition at line 1278 of file systemhtml.py.

                 generate_static_extensions=False):
        super(Dart2JSBackend, self).__init__(interface, options, False, _logger)
 
        self._generate_static_extensions = generate_static_extensions
        self._database = options.database
        self._template_loader = options.templates
        self._type_registry = options.type_registry
        self._renamer = options.renamer
        self._metadata = options.metadata
        self._interface_type_info = self._type_registry.TypeInfo(
            self._interface.id)
        self._interface_name = self._interface_type_info.interface_name()
        self._current_secondary_parent = None
        self._library_name = self._renamer.GetLibraryName(self._interface)
        # Global constants for all WebGLRenderingContextBase, WebGL2RenderingContextBase, WebGLDrawBuffers
        self._gl_constants = []
        _logger.setLevel(logging_level)
 

Member Function Documentation

◆ AddIndexer()

def scripts.systemhtml.Dart2JSBackend.AddIndexer	(	self,
		element_type,
		nullable
	)

Adds all the methods required to complete implementation of List.

Definition at line 1440 of file systemhtml.py.

    def AddIndexer(self, element_type, nullable):
        """Adds all the methods required to complete implementation of List."""
        # We would like to simply inherit the implementation of everything except
        # length, [], and maybe []=.  It is possible to extend from a base
        # array implementation class only when there is no other implementation
        # inheritance.  There might be no implementation inheritance other than
        # DOMBaseWrapper for many classes, but there might be some where the
        # array-ness is introduced by a non-root interface:
        #
        #   interface Y extends X, List<T> ...
        #
        # In the non-root case we have to choose between:
        #
        #   class YImpl extends XImpl { add List<T> methods; }
        #
        # and
        #
        #   class YImpl extends ListBase<T> { copies of transitive XImpl methods; }
        #
 
        has_indexed_getter = self.HasIndexedGetter()
 
        indexed_getter = False
        indexed_getter_nullable = nullable
        if has_indexed_getter:
            indexed_getter = ('JS("%s%s", "#[#]", this, index)' %
                              (self.SecureOutputType(element_type),
                               "|Null" if nullable else ""))
        else:
            for op in self._interface.operations:
                if op.id == 'getItem':
                    indexed_getter = 'this.getItem(index)'
                    indexed_getter_nullable = OperationTypeIsNullable(op)
                    break
            if not indexed_getter:
                for op in self._interface.operations:
                    if op.id == 'item':
                        indexed_getter = 'this.item(index)'
                        indexed_getter_nullable = OperationTypeIsNullable(op)
                        break
 
        if indexed_getter:
            self._members_emitter.Emit(
                '\n'
                '  $TYPE operator[](int index) {\n'
                '    if (JS("bool", "# >>> 0 !== # || # >= #", index,\n'
                '        index, index, length))\n'
                '      throw new IndexError.withLength(index, length, indexable: this);\n'
                '    return $INDEXED_GETTER$NULLASSERT;\n'
                '  }',
                INDEXED_GETTER=indexed_getter,
                TYPE=self.SecureOutputType(element_type,
                                           is_dart_type=False,
                                           can_narrow_type=True,
                                           nullable=nullable),
                # If the type of the operation is not nullable but the getter
                # is, we must assert non-null.
                NULLASSERT='!' if not nullable and indexed_getter_nullable \
                    else '')
 
        if 'CustomIndexedSetter' in self._interface.ext_attrs:
            self._members_emitter.Emit(
                '\n'
                '  void operator[]=(int index, $TYPE$NULLABLE value) {'
                ' JS("void", "#[#] = #", this, index, value); }',
                TYPE=self._NarrowInputType(element_type),
                NULLABLE='?' if nullable else '')
        else:
            theType = self._NarrowInputType(element_type)
            if theType == 'DomRectList':
                theType = ''
 
            self._members_emitter.Emit(
                '\n'
                '  void operator[]=(int index, $TYPE$NULLABLE value) {\n'
                '    throw new UnsupportedError("Cannot assign element of immutable List.");\n'
                '  }\n',
                TYPE=theType,
                NULLABLE='?' if nullable else '')
 
        self.EmitListMixin(self._DartType(element_type), nullable)
 

◆ AdditionalImplementedInterfaces()

def scripts.systemhtml.Dart2JSBackend.AdditionalImplementedInterfaces ( self )

Reimplemented from scripts.htmldartgenerator.HtmlDartGenerator.

Definition at line 1306 of file systemhtml.py.

    def AdditionalImplementedInterfaces(self):
        implements = super(Dart2JSBackend,
                           self).AdditionalImplementedInterfaces()
        if self._interface_type_info.list_item_type() and self.HasIndexedGetter(
        ):
            item_type = self._type_registry.TypeInfo(
                self._interface_type_info.list_item_type()).dart_type()
            if self._interface_type_info.list_item_type_nullable():
                item_type += '?'
            implements.append('JavaScriptIndexingBehavior<%s>' % item_type)
        return implements
 

◆ AmendIndexer()

def scripts.systemhtml.Dart2JSBackend.AmendIndexer	(	self,
		element_type
	)

Definition at line 1836 of file systemhtml.py.

    def AmendIndexer(self, element_type):
        pass
 

◆ CustomJSMembers()

def scripts.systemhtml.Dart2JSBackend.CustomJSMembers ( self )

Definition at line 2218 of file systemhtml.py.

    def CustomJSMembers(self):
        return _js_custom_members
 

◆ EmitAttribute()

def scripts.systemhtml.Dart2JSBackend.EmitAttribute	(	self,
		attribute,
		html_name,
		read_only
	)

Definition at line 1522 of file systemhtml.py.

    def EmitAttribute(self, attribute, html_name, read_only):
        if self._HasCustomImplementation(attribute.id):
            return
 
        if IsPureInterface(self._interface.id, self._database):
            self._AddAttributeUsingProperties(attribute, html_name, read_only)
            return
 
        output_type = self.SecureOutputType(attribute.type.id,
                                            can_narrow_type=read_only,
                                            nullable=attribute.type.nullable)
 
        rename = self._RenamingAnnotation(attribute.id, html_name)
        metadata = self._Metadata(attribute.type.id, attribute.id, output_type,
            attribute.type.nullable)
 
        is_compat = self._mdn_reader.is_compatible(attribute)
 
        # If the attribute is shadowing, we can't generate a shadowing
        # getter or setter (Issue 1633).
        # TODO(sra): _FindShadowedAttribute does not take into account the html
        # renaming. We should be looking for another attribute that has the
        # same html_name. Two attributes with the same IDL name might not match
        # if one is renamed.
        # TODO(srujzs): Determine if logic behind shadowing is still true here
        # and below with the transition to natives.
        (super_attribute,
         super_attribute_interface) = self._FindShadowedAttribute(attribute)
 
        if super_attribute:
            if is_compat is None:
                # If there is no compatibility info on this attribute, we use
                # the parent attribute's compatibility info.
                is_compat = self._mdn_reader.is_compatible(super_attribute)
                self._mdn_reader.set_compatible(attribute, is_compat)
            if read_only or self._SafeToIgnoreShadowingMember(html_name):
                if attribute.type.id == super_attribute.type.id:
                    # Compatible attribute, use the superclass property.  This
                    # works because JavaScript will do its own dynamic dispatch.
 
                    # Nullability is determined by attribute compatibility.
                    nullable = not is_compat or attribute.type.nullable
                    self._members_emitter.Emit(
                        '\n'
                        '  // Use implementation from $SUPER.\n'
                        '  // $GET_TYPE get $NAME native;\n'
                        '  // void set $NAME($SET_TYPE value) native;\n',
                        SUPER=super_attribute_interface,
                        NAME=html_name,
                        GET_TYPE=self.SecureOutputType(attribute.type.id,
                            can_narrow_type=read_only,
                            nullable=nullable),
                        SET_TYPE=self.SecureOutputType(attribute.type.id,
                            can_narrow_type=read_only,
                            nullable=nullable or \
                                'TreatNullAs' in attribute.ext_attrs))
                    return
            self._members_emitter.Emit('\n  // Shadowing definition.')
            self._AddAttributeUsingProperties(attribute, html_name, read_only,
                rename, metadata)
            return
 
        # If the attribute is shadowed incompatibly in a subclass then we also
        # can't just generate it as a getter/setter. In particular, this happens
        # with DomMatrixReadOnly and its subclass DomMatrix. Force the
        # superclass to generate getters. Hardcoding the known problem classes
        # for now.
        # TODO(alanknight): Fix this more generally.
        if (self._interface.id == 'DOMMatrixReadOnly' or
                self._interface.id == 'DOMPointReadOnly' or
                self._interface.id == 'DOMRectReadOnly'):
            self._AddAttributeUsingProperties(attribute, html_name, read_only,
                rename, metadata)
            return
 
        # If the type has a conversion we need a getter or setter to contain the
        # conversion code.
        if (self._OutputConversion(attribute.type.id, attribute.id) or
                self._InputConversion(attribute.type.id, attribute.id)):
            self._AddAttributeUsingProperties(attribute, html_name, read_only,
                rename, metadata)
            return
 
        input_type = self._NarrowInputType(attribute.type.id)
        if attribute.type.nullable or not is_compat:
            input_type += '?'
        if not read_only:
            if attribute.type.id == 'Promise':
                _logger.warn('R/W member is a Promise: %s.%s' %
                             (self._interface.id, html_name))
            self._AddAttributeUsingProperties(attribute, html_name, read_only,
                                              rename, metadata)
        else:
            if attribute.type.id == 'Promise':
                lookupOp = "%s.%s" % (self._interface.id, html_name)
                promiseFound = _GetPromiseAttributeType(lookupOp)
                promiseType = 'Future'
                promiseCall = 'promiseToFuture'
                type_description = ''
                if promiseFound is not (None):
                    paramType = promiseFound.get('type')
                    if 'maplike' in promiseFound:
                        promiseCall = 'promiseToFuture<dynamic>'
                        promiseType = 'Future'
                    elif paramType == 'dictionary':
                        # It's a dictionary so return as a Map.
                        promiseCall = 'promiseToFutureAsMap'
                        output_conversion = self._OutputConversion("Dictionary",
                                                                   None)
                        nullability = '?' if output_conversion.nullable_output \
                            else ''
                        promiseType = 'Future<Map<String, dynamic>' + \
                            nullability + '>'
                    elif paramType:
                        promiseCall = 'promiseToFuture<%s>' % paramType
                        promiseType = 'Future<%s>' % paramType
 
                    if 'creates' in promiseFound:
                        createsType = promiseFound['creates']
                        type_description = 'creates:%s;' % createsType
 
                if attribute.type.nullable:
                    promiseType += '?'
 
                template = '\n  $RENAME$(ANNOTATIONS)$TYPE get $NAME => '\
                    '$PROMISE_CALL(JS("$TYPE_DESC", "#.$NAME", this));\n'
 
                self._members_emitter.Emit(
                    template,
                    RENAME=rename,
                    ANNOTATIONS=metadata,
                    TYPE=promiseType,
                    PROMISE_CALL=promiseCall,
                    TYPE_DESC=type_description,
                    NAME=html_name,)
            else:
                # Need to use a getter for list.length properties so we can
                # add a setter which throws an exception, satisfying List
                # API.
                if self._interface_type_info.list_item_type() and \
                    html_name == 'length':
                    template = (
                        '\n  $RENAME$(ANNOTATIONS)$TYPE get $NAME => ' +
                        'JS("$TYPE", "#.$NAME", this);\n')
                    self._members_emitter.Emit(
                        template,
                        RENAME=rename,
                        ANNOTATIONS=metadata,
                        NAME=html_name,
                        TYPE=input_type
                        if output_type == 'double' else output_type)
                else:
                    # Transform to native getters/setters.
                    # TODO(srujzs): Should the logic for types and doubles from
                    # above and before stay the same here?
                    self._AddAttributeUsingProperties(attribute, html_name,
                        read_only, rename, metadata)
 

◆ EmitOperation()

def scripts.systemhtml.Dart2JSBackend.EmitOperation	(	self,
		info,
		html_name,
		dart_js_interop = `False`
	)

Arguments:
info: An OperationInfo object.

Definition at line 1845 of file systemhtml.py.

    def EmitOperation(self, info, html_name, dart_js_interop=False):
        """
    Arguments:
      info: An OperationInfo object.
    """
        if self._HasCustomImplementation(info.name):
            return
 
        if IsPureInterface(self._interface.id, self._database):
            self._AddInterfaceOperation(info, html_name)
        elif info.callback_args:
            self._AddFutureifiedOperation(info, html_name)
        else:
            if any(
                    self._OperationRequiresConversions(op)
                    for op in info.overloads):
                lookupOp = "%s.%s" % (self._interface.id, html_name)
                if (_GetPromiseOperationType(lookupOp) or info.type_name == 'Promise') and \
                  not _IsPromiseOperationGenerateCall(lookupOp):
                    self._AddDirectNativeOperation(info, html_name)
                else:
                    # Any conversions needed?
                    self._AddOperationWithConversions(info, html_name)
            else:
                self._AddDirectNativeOperation(info, html_name)
 

◆ EmitStaticFactoryOverload()

def scripts.systemhtml.Dart2JSBackend.EmitStaticFactoryOverload	(	self,
		constructor_info,
		name,
		arguments,
		emitter
	)

Definition at line 1396 of file systemhtml.py.

                                  emitter):
        if self._interface_type_info.has_generated_interface():
            # Use dart_type name, we're generating.
            interface_name = self._interface_type_info.interface_name()
        else:
            # Use the implementation name the interface is suppressed.
            interface_name = self._interface_type_info.implementation_name()
 
        index = len(arguments)
        arguments = constructor_info.ParametersAsArgumentList(index)
        if arguments:
            arguments = ', ' + arguments
        (emitter if (emitter != None) else self._members_emitter).Emit(
            "  static $INTERFACE_NAME $NAME($PARAMETERS) => "
            "JS('$INTERFACE_NAME', 'new $CTOR_NAME($PLACEHOLDERS)'$ARGUMENTS);\n",
            INTERFACE_NAME=interface_name,
            NAME=name,
            # TODO(antonm): add types to parameters.
            PARAMETERS=constructor_info.ParametersAsArgumentList(index),
            CTOR_NAME=constructor_info.name or self._interface.doc_js_name,
            PLACEHOLDERS=','.join(['#'] * index),
            ARGUMENTS=arguments)
 

◆ FinishInterface()

def scripts.systemhtml.Dart2JSBackend.FinishInterface ( self )

Definition at line 1344 of file systemhtml.py.

    def FinishInterface(self):
        pass
 

◆ GenerateCallback()

def scripts.systemhtml.Dart2JSBackend.GenerateCallback	(	self,
		info
	)

Definition at line 1303 of file systemhtml.py.

    def GenerateCallback(self, info):
        pass
 

◆ GenerateCustomFactory()

def scripts.systemhtml.Dart2JSBackend.GenerateCustomFactory	(	self,
		constructor_info
	)

Definition at line 1366 of file systemhtml.py.

    def GenerateCustomFactory(self, constructor_info):
        # Custom factory will be taken from the template.
        return self._interface.doc_js_name in _js_custom_constructors
 

◆ GetSupportCheck()

def scripts.systemhtml.Dart2JSBackend.GetSupportCheck ( self )

Return a tuple of the support check function signature and the support
test itself. If no parameters are supplied, we assume the default.

Definition at line 1350 of file systemhtml.py.

    def GetSupportCheck(self):
        """Return a tuple of the support check function signature and the support
    test itself. If no parameters are supplied, we assume the default."""
        if self._interface.doc_js_name in _js_support_checks_additional_element:
            if self._interface.doc_js_name in _svg_element_constructors:
                lib_prefix = 'Svg'
                constructors = _svg_element_constructors
            else:
                lib_prefix = ''
                constructors = _html_element_constructors
            return (js_support_checks.get(self._interface.doc_js_name) +
                    " && (new %sElement.tag('%s') is %s)" %
                    (lib_prefix, constructors[self._interface.doc_js_name],
                     self._renamer.RenameInterface(self._interface)))
        return js_support_checks.get(self._interface.doc_js_name)
 

◆ HasIndexedGetter()

def scripts.systemhtml.Dart2JSBackend.HasIndexedGetter ( self )

Definition at line 1426 of file systemhtml.py.

    def HasIndexedGetter(self):
        ext_attrs = self._interface.ext_attrs
        has_indexed_getter = 'CustomIndexedGetter' in ext_attrs
        for operation in self._interface.operations:
            if operation.id == 'item' and 'getter' in operation.specials \
                and not self._OperationRequiresConversions(operation):
                has_indexed_getter = True
                break
            if operation.id == '__getter__' and 'getter' in operation.specials \
                and not self._OperationRequiresConversions(operation):
                has_indexed_getter = True
                break
        return has_indexed_getter
 

◆ HasSupportCheck()

def scripts.systemhtml.Dart2JSBackend.HasSupportCheck ( self )

Definition at line 1347 of file systemhtml.py.

    def HasSupportCheck(self):
        return self._interface.doc_js_name in js_support_checks
 

◆ ImplementationTemplate()

def scripts.systemhtml.Dart2JSBackend.ImplementationTemplate ( self )

Definition at line 1322 of file systemhtml.py.

    def ImplementationTemplate(self):
        template_file = ('impl_%s.darttemplate' % self._interface.doc_js_name)
        template_file_content = self._template_loader.TryLoad(template_file)
        if not (template_file_content):
            if self._interface.isMaplike and self._interface.isMaplike_ro:
                # TODO(terry): There are no mutable maplikes yet.
                template_file_content = self._template_loader.Load(
                    'dart2js_maplike_impl.darttemplate')
 
            else:
                if CanUseStaticExtensions(self._interface_name,
                                          self._generate_static_extensions):
                    template_file_content = self._template_loader.Load(
                        'dart2js_static_extension_impl.darttemplate')
                else:
                    template_file_content = self._template_loader.Load(
                        'dart2js_impl.darttemplate')
        return template_file_content
 

◆ ImplementsMergedMembers()

def scripts.systemhtml.Dart2JSBackend.ImplementsMergedMembers ( self )

Definition at line 1300 of file systemhtml.py.

    def ImplementsMergedMembers(self):
        return True
 

◆ IsConstructorArgumentOptional()

def scripts.systemhtml.Dart2JSBackend.IsConstructorArgumentOptional	(	self,
		argument
	)

Definition at line 1393 of file systemhtml.py.

    def IsConstructorArgumentOptional(self, argument):
        return argument.optional
 

◆ MakeFactoryCall()

def scripts.systemhtml.Dart2JSBackend.MakeFactoryCall	(	self,
		factory,
		method,
		arguments,
		constructor_info
	)

Definition at line 1370 of file systemhtml.py.

    def MakeFactoryCall(self, factory, method, arguments, constructor_info):
        if factory is 'document' and method is 'createElement' \
            and not ',' in arguments \
            and not self._HasUnreliableFactoryConstructor():
            return emitter.Format(
                "JS$CAST("
                "'returns:$INTERFACE_NAME;creates:$INTERFACE_NAME;new:true',"
                " '#.$METHOD(#)', $FACTORY, $ARGUMENTS)",
                CAST='<' + self._interface_type_info.interface_name() + '>',
                INTERFACE_NAME=self._interface_type_info.interface_name(),
                FACTORY=factory,
                METHOD=method,
                ARGUMENTS=arguments)
        return emitter.Format('$FACTORY.$METHOD($ARGUMENTS)$CAST',
                              FACTORY=factory,
                              METHOD=method,
                              ARGUMENTS=arguments,
                              CAST=' as ' +
                              self._interface_type_info.interface_name())
 

◆ NativeSpec()

def scripts.systemhtml.Dart2JSBackend.NativeSpec ( self )

Definition at line 1318 of file systemhtml.py.

    def NativeSpec(self):
        native_spec = MakeNativeSpec(self._interface.javascript_binding_name)
        return '@Native("%s")\n' % native_spec
 

◆ OmitOperationOverrides()

def scripts.systemhtml.Dart2JSBackend.OmitOperationOverrides ( self )

Reimplemented from scripts.htmldartgenerator.HtmlDartGenerator.

Definition at line 1842 of file systemhtml.py.

    def OmitOperationOverrides(self):
        return True
 

◆ RootClassName()

def scripts.systemhtml.Dart2JSBackend.RootClassName ( self )

Definition at line 1839 of file systemhtml.py.

    def RootClassName(self):
        return 'JavaScriptObject'
 

◆ SecondaryContext()

def scripts.systemhtml.Dart2JSBackend.SecondaryContext	(	self,
		interface
	)

Definition at line 1420 of file systemhtml.py.

    def SecondaryContext(self, interface):
        if interface is not self._current_secondary_parent:
            self._current_secondary_parent = interface
            self._members_emitter.Emit(
                '\n  // From $WHERE\n', WHERE=interface.id)
 

◆ StartInterface()

def scripts.systemhtml.Dart2JSBackend.StartInterface	(	self,
		members_emitter
	)

Definition at line 1341 of file systemhtml.py.

    def StartInterface(self, members_emitter):
        self._members_emitter = members_emitter
 

The documentation for this class was generated from the following file:

third_party/dart-lang/sdk/tools/dom/scripts/systemhtml.py

Public Member Functions

Detailed Description

Constructor & Destructor Documentation

◆ __init__()

Member Function Documentation

◆ AddIndexer()

◆ AdditionalImplementedInterfaces()

◆ AmendIndexer()

◆ CustomJSMembers()

◆ EmitAttribute()

◆ EmitOperation()

◆ EmitStaticFactoryOverload()

◆ FinishInterface()

◆ GenerateCallback()

◆ GenerateCustomFactory()

◆ GetSupportCheck()

◆ HasIndexedGetter()

◆ HasSupportCheck()

◆ ImplementationTemplate()

◆ ImplementsMergedMembers()

◆ IsConstructorArgumentOptional()

◆ MakeFactoryCall()

◆ NativeSpec()

◆ OmitOperationOverrides()

◆ RootClassName()

◆ SecondaryContext()

◆ StartInterface()

◆ init()