Removing interfaces from dart:html

lib/html/scripts/systemhtml.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 system to generate
 Dart:html APIs from the IDL database."""
 
 import emitter
 
@@ skipping 314 matching lines @@
   infos = _html_element_constructors[typename]
   if isinstance(infos, str):
     infos = ElementConstructorInfo(tag=infos)
   if not isinstance(infos, list):
     infos = [infos]
   return infos
 
 def EmitHtmlElementFactoryConstructors(emitter, infos, typename, class_name):
   for info in infos:
     constructor_info = info.ConstructorInfo(typename)
+
     inits = emitter.Emit(
         '\n'
-        '  factory $CONSTRUCTOR($PARAMS) {\n'
+        '  static $RETURN_TYPE $CONSTRUCTOR($PARAMS) {\n'
         '    $CLASS _e = _document.$dom_createElement("$TAG");\n'
         '$!INITS'
         '    return _e;\n'
         '  }\n',
-        CONSTRUCTOR=constructor_info.ConstructorFullName(),
+        RETURN_TYPE=constructor_info.type_name,
+        CONSTRUCTOR=constructor_info.ConstructorFactoryName(DartType),
         CLASS=class_name,
         TAG=info.tag,
         PARAMS=constructor_info.ParametersInterfaceDeclaration(DartType))
     for param in constructor_info.param_infos:
       inits.Emit('    if ($E != null) _e.$E = $E;\n', E=param.name)
 
 
 # These classes require an explicit declaration for the "on" method even though
 # they don't declare any unique events, because the concrete class hierarchy
 # doesn't match the interface hierarchy.
@@ skipping 126 matching lines @@
       self._interface_emitter = self._system._emitters.FileEmitter(path)
     else:
       self._interface_emitter = emitter.Emitter()
 
     template_file = 'interface_%s.darttemplate' % self._html_interface_name
     interface_template = (self._system._templates.TryLoad(template_file) or
                           self._system._templates.Load('interface.darttemplate'))
 
     typename = self._html_interface_name
 
-    extends = []
-    suppressed_extends = []
+    implements = []
+    suppressed_implements = []
 
     for parent in self._interface.parents:
       # TODO(vsm): Remove source_filter.
       if MatchSourceFilter(parent):
         # Parent is a DOM type.
-        extends.append(self._DartType(parent.type.id))
+        implements.append(self._DartType(parent.type.id))
       elif '<' in parent.type.id:
         # Parent is a Dart collection type.
         # TODO(vsm): Make this check more robust.
-        extends.append(self._DartType(parent.type.id))
+        implements.append(self._DartType(parent.type.id))
       else:
-        suppressed_extends.append('%s.%s' %
+        suppressed_implements.append('%s.%s' %
             (self._common_prefix, self._DartType(parent.type.id)))
 
     comment = ' extends'
-    extends_str = ''
-    if extends:
-      extends_str += ' extends ' + ', '.join(extends)
+    implements_str = ''
+    if implements:
+      implements_str += ' implements ' + ', '.join(implements)
       comment = ','
-    if suppressed_extends:
-      extends_str += ' /*%s %s */' % (comment, ', '.join(suppressed_extends))
+    if suppressed_implements:
+      implements_str += ' /*%s %s */' % (comment,
+          ', '.join(suppressed_implements))
 
     factory_provider = None
     if typename in interface_factories:
       factory_provider = interface_factories[typename]
 
     constructors = []
     constructor_info = AnalyzeConstructor(self._interface)
     if constructor_info:
       constructors.append(constructor_info)
       factory_provider = '_' + typename + 'FactoryProvider'
@@ skipping 18 matching lines @@
           self._html_interface_name,
           self._backend.ImplementationClassName())
 
     for info in infos:
       constructors.append(info.ConstructorInfo(typename))
       if factory_provider:
         assert factory_provider == info.factory_provider_name
       else:
         factory_provider = info.factory_provider_name
 
-    if factory_provider:
-      extends_str += ' default ' + factory_provider
-
     # TODO(vsm): Add appropriate package / namespace syntax.
     (self._type_comment_emitter,
      self._members_emitter,
      self._top_level_emitter) = self._interface_emitter.Emit(
          interface_template + '$!TOP_LEVEL',
          ID=typename,
-         EXTENDS=extends_str)
+         EXTENDS=implements_str)
 
     self._type_comment_emitter.Emit("/// @domName $DOMNAME",
         DOMNAME=self._interface.doc_js_name)
 
     if self._backend.HasImplementation():
       path = self._backend.FilePathForDartImplementation()
       self._system._dart_interface_file_paths.append(path)
       self._implementation_emitter = self._system._emitters.FileEmitter(path)
     else:
       self._implementation_emitter = emitter.Emitter()
     self._backend.SetImplementationEmitter(self._implementation_emitter)
     self._implementation_members_emitter = self._backend.StartInterface()
 
     for constructor_info in constructors:
-      self._members_emitter.Emit(
-          '\n'
-          '  $CTOR($PARAMS);\n',
-          CTOR=self._DartType(constructor_info.ConstructorFullName()),
-          PARAMS=constructor_info.ParametersInterfaceDeclaration(self._DartType))
+      constructor_info.GenerateFactoryInvocation(
+          self._DartType, self._members_emitter, factory_provider)
 
     element_type = MaybeTypedArrayElementTypeInHierarchy(
         self._interface, self._system._database)
     if element_type:
       self._members_emitter.Emit(
           '\n'
-          '  $CTOR(int length);\n'
+          '  factory $CTOR(int length) =>\n'
+          '    $FACTORY.create$(CTOR)(length);\n'
           '\n'
-          '  $CTOR.fromList(List<$TYPE> list);\n'
+          '  factory $CTOR.fromList(List<$TYPE> list) =>\n'
+          '    $FACTORY.create$(CTOR)_fromList(list);\n'
           '\n'
-          '  $CTOR.fromBuffer(ArrayBuffer buffer,'
-                            ' [int byteOffset, int length]);\n',
+          '  factory $CTOR.fromBuffer(ArrayBuffer buffer, [int byteOffset, int length]) => \n'
+          '    $FACTORY.create$(CTOR)_fromBuffer(buffer, byteOffset, length);\n',
         CTOR=self._interface.id,
-        TYPE=self._DartType(element_type))
+        TYPE=self._DartType(element_type),
+        FACTORY=factory_provider)
 
     self._GenerateEvents()
 
     old_backend = self._backend
     if not self._backend.ImplementsMergedMembers():
       self._backend = HtmlGeneratorDummyBackend()
     for merged_interface in _merged_html_interfaces:
       if _merged_html_interfaces[merged_interface] == self._interface.id:
         merged_interface = self._database.GetInterface(merged_interface)
         self.AddMembers(merged_interface)
@@ skipping 17 matching lines @@
         self._interface.id, dom_name, 'set:')
     read_only = IsReadOnly(attribute) or not html_setter_name
 
     # We don't yet handle inconsistent renames of the getter and setter yet.
     assert(not html_setter_name or html_name == html_setter_name)
 
     if not is_secondary:
       self._members_emitter.Emit('\n  /** @domName $DOMINTERFACE.$DOMNAME */',
           DOMINTERFACE=attribute.doc_js_interface_name,
           DOMNAME=dom_name)
-      modifier = 'final ' if read_only else ''
-      self._members_emitter.Emit('\n  $MODIFIER$TYPE $NAME;\n',
-                                 MODIFIER=modifier,
+      if read_only:
+        template = '\n  abstract $TYPE get $NAME;\n'
+      else:
+        template = '\n  $TYPE $NAME;\n'
+
+      self._members_emitter.Emit(template,
                                  NAME=html_name,
                                  TYPE=self._DartType(attribute.type.id))
+
     self._backend.AddAttribute(attribute, html_name, read_only)
 
   def AddSecondaryAttribute(self, interface, attribute):
     self._backend.SecondaryContext(interface)
     self.AddAttribute(attribute, True)
 
   def AddOperation(self, info, skip_declaration=False):
     """
     Arguments:
       operations - contains the overloads, one or more operations with the same
@@ skipping 47 matching lines @@
     parent_events_interface = self._shared.GetParentEventsClass(self._interface)
     parent_events_class = '_%sImpl' % parent_events_interface
 
     if not event_attrs:
       self._EmitEventGetter(parent_events_interface, parent_events_class)
       return
 
     self._EmitEventGetter(events_interface, events_class)
 
     events_members = self._interface_emitter.Emit(
-        '\ninterface $INTERFACE extends $PARENTS {\n$!MEMBERS}\n',
+        '\nabstract class $INTERFACE implements $PARENTS {\n$!MEMBERS}\n',
         INTERFACE=events_interface,
         PARENTS=', '.join(
             self._shared.GetParentsEventsClasses(self._interface)))
 
     # TODO(jacobr): specify the type of _ptr as EventTarget
     implementation_events_members = self._implementation_emitter.Emit(
         '\n'
         'class $CLASSNAME extends $SUPER implements $INTERFACE {\n'
         '  $CLASSNAME(_ptr) : super(_ptr);\n'
         '$!MEMBERS}\n',
@@ skipping 521 matching lines @@
     return HtmlDart2JSClassGenerator(self, interface)
 
   def GenerateLibraries(self, dart_files):
     self._GenerateLibFile(
         'html_dart2js.darttemplate',
         os.path.join(self._output_dir, 'html_dart2js.dart'),
         dart_files)
 
   def Finish(self):
     pass