Remove ParamInfo.dart_type field.

lib/html/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 copy
 import re
@@ skipping 130 matching lines @@
 def MatchSourceFilter(thing):
   return 'WebKit' in thing.annotations or 'Dart' in thing.annotations
 
 
 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.
-    dart_type: DartType of parameter.
     is_optional: Parameter optionality.
   """
-  def __init__(self, name, type_id, dart_type, is_optional):
+  def __init__(self, name, type_id, is_optional):
     self.name = name
     self.type_id = type_id
-    self.dart_type = dart_type
     self.is_optional = is_optional
 
   def Copy(self):
-    return ParamInfo(self.name, self.type_id, self.dart_type, self.is_optional)
+    return ParamInfo(self.name, self.type_id, self.is_optional)
 
   def __repr__(self):
-    content = 'name = %s, type_id = %s, dart_type = %s, is_optional = %s' % (
-        self.name, self.type_id, self.dart_type, self.is_optional)
+    content = 'name = %s, type_id = %s, is_optional = %s' % (
+        self.name, self.type_id, self.is_optional)
     return '<ParamInfo(%s)>' % content
 
 
 # Given a list of overloaded arguments, render dart arguments.
 def _BuildArguments(args, interface, constructor=False):
   def IsOptional(argument):
     if 'Callback' in argument.ext_attrs:
       # Callbacks with 'Optional=XXX' are treated as optional arguments.
       return 'Optional' in argument.ext_attrs
     if constructor:
       # FIXME: Constructors with 'Optional=XXX' shouldn't be treated as
       # optional arguments.
       return 'Optional' in argument.ext_attrs
     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:
-      if len(type_ids) == 1:
-        return (type_ids[0], type_ids[0])
-      else:
-        return (None, type_ids[0])
+      return type_ids[0]
     else:
-      return (None, TypeName(type_ids, interface))
+      return None
 
   result = []
 
   is_optional = False
   for arg_tuple in map(lambda *x: x, *args):
     is_optional = is_optional or any(arg is None or IsOptional(arg) for arg in arg_tuple)
 
     filtered = filter(None, arg_tuple)
-    (type_id, dart_type) = OverloadedType(filtered)
+    type_id = OverloadedType(filtered)
     name = OverloadedName(filtered)
-    result.append(ParamInfo(name, type_id, dart_type, is_optional))
+    result.append(ParamInfo(name, type_id, is_optional))
 
   return result
 
 def IsOptional(argument):
   return ('Optional' in argument.ext_attrs and
           argument.ext_attrs['Optional'] == None)
 
 def AnalyzeOperation(interface, operations):
   """Makes operation calling convention decision for a set of overloads.
 
@@ skipping 119 matching lines @@
     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.
     param_infos: A list of ParamInfo.
   """
 
   def ParametersInterfaceDeclaration(self, rename_type):
     """Returns a formatted string declaring the parameters for the interface."""
     def type_function(param):
-      # TODO(podivilov): replace param.dart_type field with param.is_optional
-      dart_type = param.dart_type
-      if dart_type != 'Dynamic':
-        dart_type = rename_type(dart_type)
+      dart_type = rename_type(param.type_id) if param.type_id else 'Dynamic'
       return TypeOrNothing(dart_type, param.type_id)
     return self._FormatParams(self.param_infos, None, type_function)
 
   def ParametersImplementationDeclaration(self, rename_type):
     """Returns a formatted string declaring the parameters for the
     implementation.
 
     Args:
       rename_type: A function that allows the types to be renamed.
         The function is applied to the parameter's dart_type.
     """
     def type_function(param):
-      # TODO(podivilov): replace param.dart_type field with param.is_optional
-      dart_type = param.dart_type
-      if dart_type != 'Dynamic':
-        dart_type = rename_type(dart_type)
+      dart_type = rename_type(param.type_id) if param.type_id else 'Dynamic'
       return TypeOrNothing(dart_type)
     return self._FormatParams(self.param_infos, 'null', type_function)
 
   def ParametersAsArgumentList(self, parameter_count = None):
     """Returns a string of the parameter names suitable for passing the
     parameters as arguments.
     """
     if parameter_count is None:
       parameter_count = len(self.param_infos)
     return ', '.join(map(
@@ skipping 82 matching lines @@
       if param_info.is_optional:
         EmitOptionalParameterInvocation(index)
 
 
   def CopyAndWidenDefaultParameters(self):
     """Returns equivalent OperationInfo, but default parameters are Dynamic."""
     info = copy.copy(self)
     info.param_infos = [param.Copy() for param in self.param_infos]
     for param in info.param_infos:
       if param.is_optional:
-        param.dart_type = 'Dynamic'
+        param.type_id = None
     return info
 
 
 def ConstantOutputOrder(a, b):
   """Canonical output ordering for constants."""
   if a.id < b.id: return -1
   if a.id > b.id: return 1
   return 0
 
 
@@ skipping 626 matching lines @@
             self._database.GetInterface(type_name))
       else:
         dart_interface_name = type_name
       return InterfaceIDLTypeInfo(type_name, type_data, dart_interface_name)
 
     if type_data.clazz == 'ListLike':
       return ListLikeIDLTypeInfo(type_name, type_data, self.TypeInfo(type_data.item_type))
 
     class_name = '%sIDLTypeInfo' % type_data.clazz
     return globals()[class_name](type_name, type_data)