Move dart:dom implementation classes to dart:html library.

lib/dom/scripts/systemnative.py

 #!/usr/bin/python
 # 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 the systems to generate
 native binding from the IDL database."""
 
 import emitter
 import os
@@ skipping 189 matching lines @@
   def _FilePathForDartFactoryProviderImplementation(self, interface_name):
     return os.path.join(self._output_dir, 'dart',
                         '%sFactoryProviderImplementation.dart' % interface_name)
 
   def _FilePathForCppHeader(self, interface_name):
     return os.path.join(self._output_dir, 'cpp', 'Dart%s.h' % interface_name)
 
   def _FilePathForCppImplementation(self, interface_name):
     return os.path.join(self._output_dir, 'cpp', 'Dart%s.cpp' % interface_name)
 
+  def DartImplementationFiles(self):
+    return self._dom_impl_files
+
 
 class NativeImplementationGenerator(object):
   """Generates Dart implementation for one DOM IDL interface."""
 
   def __init__(self, system, interface,
                dart_impl_emitter, cpp_header_emitter, cpp_impl_emitter,
                base_members, templates):
     """Generates Dart and C++ code for the given interface.
 
     Args:
@@ skipping 12 matching lines @@
     self._system = system
     self._interface = interface
     self._dart_impl_emitter = dart_impl_emitter
     self._cpp_header_emitter = cpp_header_emitter
     self._cpp_impl_emitter = cpp_impl_emitter
     self._base_members = base_members
     self._templates = templates
     self._current_secondary_parent = None
 
   def StartInterface(self):
-    self._class_name = self._ImplClassName(self._interface.id)
     self._interface_type_info = GetIDLTypeInfo(self._interface.id)
     self._members_emitter = emitter.Emitter()
     self._cpp_declarations_emitter = emitter.Emitter()
     self._cpp_impl_includes = set()
     self._cpp_definitions_emitter = emitter.Emitter()
     self._cpp_resolver_emitter = emitter.Emitter()
 
     self._GenerateConstructors()
     self._GenerateEvents()
 
@@ skipping 62 matching lines @@
         self._interface.id, self._interface.ext_attrs, raises_dom_exceptions)
     self._GenerateNativeCallback(callback_name='constructorCallback',
         parameter_definitions=parameter_definitions_emitter.Fragments(),
         needs_receiver=False, invocation=invocation,
         raises_exceptions=raises_exceptions)
 
   def _GenerateEvents(self):
     if self._interface.id == 'DocumentFragment':
       # Interface DocumentFragment extends Element in dart:html but this fact
       # is not reflected in idls.
-      self._EmitEventGetter('ElementEventsImplementation')
+      self._EmitEventGetter('_ElementEventsImpl')
       return
 
     events_attributes = [attr for attr in self._interface.attributes
                          if attr.type.id == 'EventListener']
     if not 'EventTarget' in self._interface.ext_attrs and not events_attributes:
       return
 
     def IsEventTarget(interface):
       return ('EventTarget' in interface.ext_attrs and
               interface.id != 'EventTarget')
     is_root = not _FindParent(self._interface, self._system._database, IsEventTarget)
     if is_root:
-      self._members_emitter.Emit('  EventsImplementation _on;\n')
+      self._members_emitter.Emit('  _EventsImpl _on;\n')
 
     if not events_attributes:
       if is_root:
-        self._EmitEventGetter('EventsImplementation')
+        self._EmitEventGetter('_EventsImpl')
       return
 
-    events_class = '%sEventsImplementation' % self._interface.id
+    events_class = '_%sEventsImpl' % self._interface.id
     self._EmitEventGetter(events_class)
 
     def HasEventAttributes(interface):
       return any([a.type.id == 'EventListener' for a in interface.attributes])
     parent = _FindParent(self._interface, self._system._database, HasEventAttributes)
     if parent:
-      parent_events_class = '%sEventsImplementation' % parent.id
+      parent_events_class = '_%sEventsImpl' % parent.id
     else:
-      parent_events_class = 'EventsImplementation'
+      parent_events_class = '_EventsImpl'
     html_inteface = self._system._html_renames.get(self._interface.id, self._interface.id)
     events_members = self._dart_impl_emitter.Emit(
         '\n'
         'class $EVENTS_CLASS extends $PARENT_EVENTS_CLASS implements $EVENTS_INTERFACE {\n'
         '  $EVENTS_CLASS(_ptr) : super(_ptr);\n'
         '$!MEMBERS\n'
         '}\n',
         EVENTS_CLASS=events_class,
         PARENT_EVENTS_CLASS=parent_events_class,
-        EVENTS_INTERFACE='html.%sEvents' % html_inteface)
+        EVENTS_INTERFACE='%sEvents' % html_inteface)
 
     events_attributes = DomToHtmlEvents(self._interface.id, events_attributes)
     for event_name in events_attributes:
       events_members.Emit(
           '  EventListenerList get $HTML_NAME() => this[\'$DOM_NAME\'];\n',
           HTML_NAME=DomToHtmlEvent(event_name),
           DOM_NAME=event_name)
 
   def _EmitEventGetter(self, events_class):
     self._members_emitter.Emit(
         '\n'
         '  $EVENTS_CLASS get on() {\n'
         '    if (_on === null) _on = new $EVENTS_CLASS(this);\n'
         '    return _on;\n'
         '  }\n',
         EVENTS_CLASS=events_class)
 
   def _ImplClassName(self, interface_name):
-    return interface_name + 'Implementation'
+    return '_%sDOMImpl' % interface_name
+
+  def _DartType(self, idl_type):

[Anton Muhin, 2012/05/23 14:03:31]

shouldn't this logic belong to IDLTypeInfo?

[podivilov, 2012/05/23 14:52:40]

This is temporary, only needed because dom wrappers don't implement html
interfaces yet.

[Anton Muhin, 2012/05/23 15:25:23]

Please, add a TODO w/ explanations

On 2012/05/23 14:52:40, podivilov wrote:

[podivilov, 2012/05/24 10:33:07]

Done.

+    if idl_type in ['EventListener', 'TimeoutHandler']:
+      return idl_type
+    if idl_type in ['EventTarget', 'IDBAny', 'IDBKey']:
+      return 'Dynamic'
+    if idl_type == 'DOMStringList':
+      return 'List<String>'
+
+    type_info = GetIDLTypeInfo(idl_type)
+    if isinstance(type_info, PrimitiveIDLTypeInfo) or isinstance(type_info, SequenceIDLTypeInfo):
+      return type_info.dart_type()
+
+    if self._system._database.HasInterface(idl_type):
+      interface = self._system._database.GetInterface(idl_type)
+      if 'Callback' in interface.ext_attrs:
+        return idl_type
+      return '_%s' % idl_type
+    return idl_type
 
   def _BaseClassName(self):
     if not self._interface.parents:
-      return 'DOMWrapperBase'
+      return '_DOMWrapperBase'
 
     supertype = self._interface.parents[0].type.id
 
     # FIXME: We're currently injecting List<..> and EventTarget as
     # supertypes in dart.idl. We should annotate/preserve as
     # attributes instead.  For now, this hack lets the self._interfaces
     # inherit, but not the classes.
     # List methods are injected in AddIndexer.
     if IsDartListType(supertype) or IsDartCollectionType(supertype):
-      return 'DOMWrapperBase'
+      return '_DOMWrapperBase'
 
     if supertype == 'EventTarget':
       # Most implementors of EventTarget specify the EventListener operations
       # again.  If the operations are not specified, try to inherit from the
       # EventTarget implementation.
       #
       # Applies to MessagePort.
       if not [op for op in self._interface.operations if op.id == 'addEventListener']:
         return self._ImplClassName(supertype)
-      return 'DOMWrapperBase'
+      return '_DOMWrapperBase'
 
     return self._ImplClassName(supertype)
 
   def _IsConstructable(self):
     # FIXME: support ConstructorTemplate.
     return set(['CustomConstructor', 'V8CustomConstructor', 'Constructor', 'NamedConstructor']) & set(self._interface.ext_attrs)
 
   def _EmitFactoryProvider(self, interface_name, constructor_info):
-    factory_provider = '_' + interface_name + 'FactoryProvider'
-    implementation_class = interface_name + 'FactoryProviderImplementation'
+    factory_provider = '_%sFactoryProvider' % interface_name
+    implementation_class = '_%sFactoryProviderImpl' % interface_name
     implementation_function = 'create' + interface_name
     native_implementation_function = '%s_constructor_Callback' % interface_name
 
     # Emit private factory provider in public library.
     template_file = 'factoryprovider_%s.darttemplate' % interface_name
     template = self._system._templates.TryLoad(template_file)
     if not template:
       template = self._system._templates.Load('factoryprovider.darttemplate')
 
     dart_impl_path = self._system._FilePathForDartFactoryProvider(
         interface_name)
     self._system._dom_public_files.append(dart_impl_path)
 
+    parameters = constructor_info.ParametersImplementationDeclaration(lambda x: self._DartType(x))

[Anton Muhin, 2012/05/23 14:03:31]

nit: no need in lambda, self._DartType should work too

[podivilov, 2012/05/23 14:52:40]

Done.

+
     emitter = self._system._emitters.FileEmitter(dart_impl_path)
     emitter.Emit(
         template,
         FACTORY_PROVIDER=factory_provider,
         CONSTRUCTOR=interface_name,
-        PARAMETERS=constructor_info.ParametersImplementationDeclaration(),
+        PARAMETERS=parameters,
         IMPL_CLASS=implementation_class,
         IMPL_FUNCTION=implementation_function,
         ARGUMENTS=constructor_info.ParametersAsArgumentList())
 
     # Emit public implementation in implementation libary.
     dart_impl_path = self._system._FilePathForDartFactoryProviderImplementation(
         interface_name)
     self._system._dom_impl_files.append(dart_impl_path)
     emitter = self._system._emitters.FileEmitter(dart_impl_path)
     emitter.Emit(
         'class $IMPL_CLASS {\n'
-        '  static $INTERFACE_NAME $IMPL_FUNCTION($PARAMETERS)\n'
+        '  static $TYPE $IMPL_FUNCTION($PARAMETERS)\n'
         '      native "$NATIVE_NAME";\n'
         '}',
-        INTERFACE_NAME=interface_name,
-        PARAMETERS=constructor_info.ParametersImplementationDeclaration(),
+        PARAMETERS=parameters,
         IMPL_CLASS=implementation_class,
+        TYPE=self._ImplClassName(interface_name),
         IMPL_FUNCTION=implementation_function,
         NATIVE_NAME=native_implementation_function)
 
   def FinishInterface(self):
+    class_name = self._ImplClassName(self._interface.id)
     base = self._BaseClassName()
     self._dart_impl_emitter.Emit(
         self._templates.Load('dart_implementation.darttemplate'),
-        CLASS=self._class_name, BASE=base, INTERFACE=self._interface.id,
+        CLASS=class_name, BASE=base, INTERFACE=self._interface.id,
         MEMBERS=self._members_emitter.Fragments())
 
     self._GenerateCppHeader()
 
     self._cpp_impl_emitter.Emit(
         self._templates.Load('cpp_implementation.template'),
         INTERFACE=self._interface.id,
         INCLUDES=_GenerateCPPIncludes(self._cpp_impl_includes),
         CALLBACKS=self._cpp_definitions_emitter.Fragments(),
-        RESOLVER=self._cpp_resolver_emitter.Fragments())
+        RESOLVER=self._cpp_resolver_emitter.Fragments(),
+        DART_IMPLEMENTATION_CLASS=class_name)
 
   def _GenerateCppHeader(self):
     to_native_emitter = emitter.Emitter()
     if self._interface_type_info.custom_to_native():
       to_native_emitter.Emit(
           '    static PassRefPtr<NativeType> toNative(Dart_Handle handle, Dart_Handle& exception);\n')
     else:
       to_native_emitter.Emit(
           '    static NativeType* toNative(Dart_Handle handle, Dart_Handle& exception)\n'
           '    {\n'
@@ skipping 79 matching lines @@
       self._AddGetter(getter)
     if setter:
       self._AddSetter(setter)
 
   def AddSecondaryAttribute(self, interface, getter, setter):
     self.AddAttribute(getter, setter)
 
   def _AddGetter(self, attr):
     type_info = GetIDLTypeInfo(attr.type.id)
     dart_declaration = '%s get %s()' % (
-        type_info.dart_type(), DartDomNameOfAttribute(attr))
+        self._DartType(attr.type.id), DartDomNameOfAttribute(attr))
     is_custom = 'Custom' in attr.ext_attrs or 'CustomGetter' in attr.ext_attrs
     cpp_callback_name = self._GenerateNativeBinding(attr.id, 1,
         dart_declaration, 'Getter', is_custom)
     if is_custom:
       return
 
     arguments = []
     parameter_definitions_emitter = emitter.Emitter()
     raises_exceptions = self._GenerateCallWithHandling(attr, parameter_definitions_emitter, arguments)
     raises_exceptions = raises_exceptions or attr.get_raises
@@ skipping 23 matching lines @@
 
     function_expression = self._GenerateWebCoreFunctionExpression(webcore_function_name, attr)
     invocation = self._GenerateWebCoreInvocation(function_expression,
         arguments, attr.type.id, attr.ext_attrs, attr.get_raises)
     self._GenerateNativeCallback(cpp_callback_name, parameter_definitions_emitter.Fragments(),
         True, invocation, raises_exceptions=raises_exceptions)
 
   def _AddSetter(self, attr):
     type_info = GetIDLTypeInfo(attr.type.id)
     dart_declaration = 'void set %s(%s)' % (
-        DartDomNameOfAttribute(attr), type_info.dart_type())
+        DartDomNameOfAttribute(attr), self._DartType(attr.type.id))
     is_custom = set(['Custom', 'CustomSetter', 'V8CustomSetter']) & set(attr.ext_attrs)
     cpp_callback_name = self._GenerateNativeBinding(attr.id, 2,
         dart_declaration, 'Setter', is_custom)
     if is_custom:
       return
 
     arguments = []
     parameter_definitions_emitter = emitter.Emitter()
     self._GenerateCallWithHandling(attr, parameter_definitions_emitter, arguments)
 
@@ skipping 32 matching lines @@
     #   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; }
     #
-    dart_element_type = DartType(element_type)
+    dart_element_type = self._DartType(element_type)
     if self._HasNativeIndexGetter():
       self._EmitNativeIndexGetter(dart_element_type)
     else:
       self._members_emitter.Emit(
           '\n'
           '  $TYPE operator[](int index) {\n'
           '    return item(index);\n'
           '  }\n',
           TYPE=dart_element_type)
 
@@ skipping 97 matching lines @@
         TYPE=dart_element_type)
 
   def AmendIndexer(self, element_type):
     # If interface is marked as having native indexed
     # getter or setter, we must emit overrides as it's not
     # guaranteed that the corresponding methods in C++ would be
     # virtual.  For example, as of time of writing, even though
     # Uint8ClampedArray inherits from Uint8Array, ::set method
     # is not virtual and accessing it through Uint8Array pointer
     # would lead to wrong semantics (modulo vs. clamping.)
-    dart_element_type = DartType(element_type)
+    dart_element_type = self._DartType(element_type)
 
     if self._HasNativeIndexGetter():
       self._EmitNativeIndexGetter(dart_element_type)
     if self._HasNativeIndexSetter():
       self._EmitNativeIndexSetter(dart_element_type)
 
   def _HasNativeIndexGetter(self):
     ext_attrs = self._interface.ext_attrs
     return ('CustomIndexedGetter' in ext_attrs or
         'NumericIndexedGetter' in ext_attrs)
@@ skipping 14 matching lines @@
   def _AddOperation(self, info):
     """
     Arguments:
       info: An OperationInfo object.
     """
 
     if 'CheckSecurityForNode' in info.overloads[0].ext_attrs:
       # FIXME: exclude from interface as well.
       return
 
+    parameters = info.ParametersImplementationDeclaration(lambda x: self._DartType(x))
     if 'Custom' in info.overloads[0].ext_attrs:
-      parameters = info.ParametersImplementationDeclaration()
-      dart_declaration = '%s %s(%s)' % (info.type_name, info.name, parameters)
+      dart_declaration = '%s %s(%s)' % (self._DartType(info.type_name), info.name, parameters)
       argument_count = (0 if info.IsStatic() else 1) + len(info.param_infos)
       self._GenerateNativeBinding(info.name, argument_count, dart_declaration,
           'Callback', True)
       return
 
     modifier = ''
     if info.IsStatic():
       modifier = 'static '
     body = self._members_emitter.Emit(
         '\n'
         '  $MODIFIER$TYPE $NAME($PARAMETERS) {\n'
         '$!BODY'
         '  }\n',
         MODIFIER=modifier,
-        TYPE=info.type_name,
+        TYPE=self._DartType(info.type_name),
         NAME=info.name,
-        PARAMETERS=info.ParametersImplementationDeclaration())
+        PARAMETERS=parameters)
 
     # Process in order of ascending number of arguments to ensure missing
     # optional arguments are processed early.
     overloads = sorted(info.overloads,
                        key=lambda overload: len(overload.arguments))
     self._native_version = 0
     fallthrough = self.GenerateDispatch(body, info, '    ', 0, overloads)
     if fallthrough:
       body.Emit('    throw "Incorrect number or type of arguments";\n');
 
@@ skipping 53 matching lines @@
     positive = []
     negative = []
     first_overload = overloads[0]
     param = info.param_infos[position]
 
     if position < len(first_overload.arguments):
       # FIXME: This will not work if the second overload has a more
       # precise type than the first.  E.g.,
       # void foo(Node x);
       # void foo(Element x);
-      type = DartType(first_overload.arguments[position].type.id)
+      type = self._DartType(first_overload.arguments[position].type.id)
       test = TypeCheck(param.name, type)
-      pred = lambda op: len(op.arguments) > position and DartType(op.arguments[position].type.id) == type
+      pred = lambda op: len(op.arguments) > position and self._DartType(op.arguments[position].type.id) == type
     else:
       type = None
       test = NullCheck(param.name)
       pred = lambda op: position >= len(op.arguments)
 
     for overload in overloads:
       if pred(overload):
         positive.append(overload)
       else:
         negative.append(overload)
@@ skipping 74 matching lines @@
     else:
       dispatch_emitter.Emit('$(INDENT)_$NATIVENAME($ARGS);\n'
                             '$(INDENT)return;\n',
                             INDENT=indent,
                             NATIVENAME=native_name,
                             ARGS=argument_list)
     # Generate binding.
     modifier = ''
     if operation.is_static:
       modifier = 'static '
-    dart_declaration = '%s%s _%s(%s)' % (modifier, info.type_name, native_name,
+    dart_declaration = '%s%s _%s(%s)' % (modifier, self._DartType(info.type_name), native_name,
                                        argument_list)
     is_custom = 'Custom' in operation.ext_attrs
     cpp_callback_name = self._GenerateNativeBinding(
         native_name, (0 if operation.is_static else 1) + len(operation.arguments), dart_declaration, 'Callback',
         is_custom)
     if is_custom:
       return
 
     # Generate callback.
     webcore_function_name = operation.ext_attrs.get('ImplementedAs', operation.id)
@@ skipping 189 matching lines @@
   for parent in interface.parents:
     parent_name = parent.type.id
     if not database.HasInterface(parent.type.id):
       continue
     parent_interface = database.GetInterface(parent.type.id)
     if callback(parent_interface):
       return parent_interface
     parent_interface = _FindParent(parent_interface, database, callback)
     if parent_interface:
       return parent_interface