Proper handling of sequence<T> in IDLs.

client/dom/scripts/generator.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 systems to generate
 Dart APIs from the IDL database."""
 
 import re
 
@@ skipping 216 matching lines @@
     return '*' + javascript_binding_name
 
 
 def MatchSourceFilter(filter, thing):
   if not filter:
     return True
   else:
     return any(token in thing.annotations for token in filter)
 
 def DartType(idl_type_name):
-  match = re.match(r'sequence<(\w*)>$', idl_type_name)
-  if match:
-    return 'List<%s>' % GetIDLTypeInfo(match.group(1)).dart_type()
   return GetIDLTypeInfo(idl_type_name).dart_type()
 
 # Given a list of overloaded arguments, render a dart argument.
 def _DartArg(args, interface):
   # Given a list of overloaded arguments, choose a suitable name.
   def OverloadedName(args):
     return '_OR_'.join(sorted(set(arg.id for arg in args)))
 
   # Given a list of overloaded arguments, choose a suitable type.
   def OverloadedType(args):
@@ skipping 230 matching lines @@
     self._conversion_template = conversion_template
     self._custom_to_dart = custom_to_dart
     self._conversion_includes = conversion_includes
 
   def idl_type(self):
     return self._idl_type
 
   def dart_type(self):
     if self._dart_type:
       return self._dart_type
+
+    match = re.match(r'sequence<(\w*)>$', self._idl_type)
+    if match:
+      return 'List<%s>' % DartType(match.group(1))

[podivilov, 2012/03/23 15:12:07]

nit: should be GetIDLTypeInfo(match.group(1)).dart_type()

[Anton Muhin, 2012/03/23 17:27:31]

DartType is exactly this now, no?

+
     return self._idl_type
 
   def native_type(self):
     if self._native_type:
       return self._native_type
     return self._idl_type
 
   def parameter_adapter_info(self):
     native_type = self.native_type()
     if self._ref_counted:
@@ skipping 33 matching lines @@
     if self._idl_type.startswith('SVGPathSeg'):
       include = self._idl_type.replace('Abs', '').replace('Rel', '')
     else:
       include = self._idl_type
     return ['"%s.h"' % include] + _svg_supplemental_includes
 
   def receiver(self):
     return 'receiver->'
 
   def conversion_includes(self):
-    return ['"Dart%s.h"' % include for include in [self.dart_type()] + self._conversion_includes]
+    def NeededDartType(type_name):
+      match = re.match(r'List<(\w*)>$', type_name)
+      if match:
+        return NeededDartType(match.group(1))
+      return type_name
+
+    return ['"Dart%s.h"' % include for include in [NeededDartType(self.dart_type())] + self._conversion_includes]

[podivilov, 2012/03/23 15:12:07]

Please parse the type in constructor, so you don't have to replace sequence with
list and then vice versa.

[Anton Muhin, 2012/03/23 17:27:31]

Should I do it right now?  If we're looking for optimization opportunities,
they're aplenty in this code.

On 2012/03/23 15:12:07, podivilov wrote:

 
   def conversion_cast(self, expression):
     if self._conversion_template:
       return self._conversion_template % expression
     return expression
 
   def custom_to_dart(self):
     return self._custom_to_dart
 
 class PrimitiveIDLTypeInfo(IDLTypeInfo):
@@ skipping 122 matching lines @@
     '"SVGAnimatedPropertyTearOff.h"',
     '"SVGAnimatedListPropertyTearOff.h"',
     '"SVGStaticListPropertyTearOff.h"',
     '"SVGAnimatedListPropertyTearOff.h"',
     '"SVGTransformListPropertyTearOff.h"',
     '"SVGPathSegListPropertyTearOff.h"',
 ]
 
 def GetIDLTypeInfo(idl_type_name):
   return _idl_type_registry.get(idl_type_name, IDLTypeInfo(idl_type_name))