Get rid of Dynamic.

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 240 matching lines @@
   name = _dart_attribute_renames.get(name, name)
   name = attr.ext_attrs.get('DartName', None) or name
   return name
 
 
 def TypeOrNothing(dart_type, comment=None):
   """Returns string for declaring something with |dart_type| in a context
   where a type may be omitted.
   The string is empty or has a trailing space.
   """
-  if dart_type == 'Dynamic':
+  if dart_type == 'dynamic':
     if comment:
       return '/*%s*/ ' % comment   # Just a comment foo(/*T*/ x)
     else:
-      return ''                    # foo(x) looks nicer than foo(Dynamic x)
+      return ''                    # foo(x) looks nicer than foo(var|dynamic x)
   else:
     return dart_type + ' '
 
 
 def TypeOrVar(dart_type, comment=None):
   """Returns string for declaring something with |dart_type| in a context
   where if a type is omitted, 'var' must be used instead."""
-  if dart_type == 'Dynamic':
+  if dart_type == 'dynamic':
     if comment:
       return 'var /*%s*/' % comment   # e.g.  var /*T*/ x;
     else:
       return 'var'                    # e.g.  var x;
   else:
     return dart_type
 
 
 class OperationInfo(object):
   """Holder for various derived information from a set of overloaded operations.
 
   Attributes:
     overloads: A list of IDL operation overloads with the same name.
     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 ParametersDeclaration(self, rename_type, force_optional=False):
     def FormatParam(param):
-      dart_type = rename_type(param.type_id) if param.type_id else 'Dynamic'
+      dart_type = rename_type(param.type_id) if param.type_id else 'dynamic'
       return '%s%s' % (TypeOrNothing(dart_type, param.type_id), param.name)
 
     required = []
     optional = []
     for param_info in self.param_infos:
       if param_info.is_optional:
         optional.append(param_info)
       else:
         if optional:
           raise Exception('Optional parameters cannot precede required ones: '
@@ skipping 73 matching lines @@
         FACTORY=factory_provider,
         CTOR_FACTORY_NAME=factory_name,
         FACTORY_PARAMS=self.ParametersAsArgumentList(index))
 
     for index, param_info in enumerate(self.param_infos):
       if param_info.is_optional:
         EmitOptionalParameterInvocation(index)
 
 
   def CopyAndWidenDefaultParameters(self):
-    """Returns equivalent OperationInfo, but default parameters are Dynamic."""
+    """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.type_id = None
     return info
 
 
 def ConstantOutputOrder(a, b):
   """Canonical output ordering for constants."""
@@ skipping 19 matching lines @@
     if line.strip():
       return '%s%s\n' % (indent, line)
     else:
       return '\n'
   return ''.join(FormatLine(line) for line in text.split('\n'))
 
 # Given a sorted sequence of type identifiers, return an appropriate type
 # name
 def TypeName(type_ids, interface):
   # Dynamically type this field for now.
-  return 'Dynamic'
+  return 'dynamic'
 
 def ImplementationClassNameForInterfaceName(interface_name):
   return '_%sImpl' % interface_name
 
 # ------------------------------------------------------------------------------
 
 class Conversion(object):
   """Represents a way of converting between types."""
   def __init__(self, name, input_type, output_type):
     # input_type is the type of the API input (and the argument type of the
     # conversion function)
     # output_type is the type of the API output (and the result type of the
     # conversion function)
     self.function_name = name
     self.input_type = input_type
     self.output_type = output_type
 
 #  "TYPE DIRECTION INTERFACE.MEMBER" -> conversion
 #     Specific member of interface
 #  "TYPE DIRECTION INTERFACE.*" -> conversion
 #     All members of interface getting (setting) with type.
 #  "TYPE DIRECTION" -> conversion
 #     All getters (setters) of type.
 #
 # where DIRECTION is 'get' for getters and operation return values, 'set' for
 # setters and operation arguments.  INTERFACE and MEMBER are the idl names.
 #
 
 _serialize_SSV = Conversion('_convertDartToNative_SerializedScriptValue',
-                           'Dynamic', 'Dynamic')
+                           'dynamic', 'dynamic')
 
 dart2js_conversions = {
     # Wrap non-local Windows.  We need to check EventTarget (the base type)
     # as well.  Note, there are no functions that take a non-local Window
     # as a parameter / setter.
     'DOMWindow get':
       Conversion('_convertNativeToDart_Window', 'Window', 'Window'),
     'EventTarget get':
       Conversion('_convertNativeToDart_EventTarget', 'EventTarget',
                  'EventTarget'),
     'EventTarget set':
       Conversion('_convertDartToNative_EventTarget', 'EventTarget',
                  'EventTarget'),
 
     'IDBKey get':
-      Conversion('_convertNativeToDart_IDBKey', 'Dynamic', 'Dynamic'),
+      Conversion('_convertNativeToDart_IDBKey', 'dynamic', 'dynamic'),
     'IDBKey set':
-      Conversion('_convertDartToNative_IDBKey', 'Dynamic', 'Dynamic'),
+      Conversion('_convertDartToNative_IDBKey', 'dynamic', 'dynamic'),
 
     'ImageData get':
-      Conversion('_convertNativeToDart_ImageData', 'Dynamic', 'ImageData'),
+      Conversion('_convertNativeToDart_ImageData', 'dynamic', 'ImageData'),
     'ImageData set':
-      Conversion('_convertDartToNative_ImageData', 'ImageData', 'Dynamic'),
+      Conversion('_convertDartToNative_ImageData', 'ImageData', 'dynamic'),
 
     'Dictionary get':
-      Conversion('_convertNativeToDart_Dictionary', 'Dynamic', 'Map'),
+      Conversion('_convertNativeToDart_Dictionary', 'dynamic', 'Map'),
     'Dictionary set':
-      Conversion('_convertDartToNative_Dictionary', 'Map', 'Dynamic'),
+      Conversion('_convertDartToNative_Dictionary', 'Map', 'dynamic'),
 
     'DOMString[] set':
       Conversion('_convertDartToNative_StringArray', 'List<String>', 'List'),
 
     'any set IDBObjectStore.add': _serialize_SSV,
     'any set IDBObjectStore.put': _serialize_SSV,
     'any set IDBCursor.update': _serialize_SSV,
 
     # postMessage
     'any set DedicatedWorkerContext.postMessage': _serialize_SSV,
     'any set MessagePort.postMessage': _serialize_SSV,
     'SerializedScriptValue set DOMWindow.postMessage': _serialize_SSV,
     'SerializedScriptValue set Worker.postMessage': _serialize_SSV,
 
     # receiving message via MessageEvent
     'DOMObject get MessageEvent.data':
       Conversion('_convertNativeToDart_SerializedScriptValue',
-                 'Dynamic', 'Dynamic'),
+                 'dynamic', 'dynamic'),
 
 
     # IDBAny is problematic.  Some uses are just a union of other IDB types,
     # which need no conversion..  Others include data values which require
     # serialized script value processing.
     'IDBAny get IDBCursorWithValue.value':
-      Conversion('_convertNativeToDart_IDBAny', 'Dynamic', 'Dynamic'),
+      Conversion('_convertNativeToDart_IDBAny', 'dynamic', 'dynamic'),
 
     # This is problematic.  The result property of IDBRequest is used for
     # all requests.  Read requests like IDBDataStore.getObject need
     # conversion, but other requests like opening a database return
     # something that does not need conversion.
     'IDBAny get IDBRequest.result':
-      Conversion('_convertNativeToDart_IDBAny', 'Dynamic', 'Dynamic'),
+      Conversion('_convertNativeToDart_IDBAny', 'dynamic', 'dynamic'),
 
     # "source: On getting, returns the IDBObjectStore or IDBIndex that the
     # cursor is iterating. ...".  So we should not try to convert it.
     'IDBAny get IDBCursor.source': None,
 
     # Should be either a DOMString, an Array of DOMStrings or null.
     'IDBAny get IDBObjectStore.keyPath': None,
 }
 
 def FindConversion(idl_type, direction, interface, member):
@@ skipping 368 matching lines @@
                               native_type='unsigned',
                               webcore_getter_name='getUnsignedIntegralAttribute',
                               webcore_setter_name='setUnsignedIntegralAttribute'),
     'long long': TypeData(clazz='Primitive', dart_type='int'),
     'unsigned long long': TypeData(clazz='Primitive', dart_type='int'),
     'float': TypeData(clazz='Primitive', dart_type='num', native_type='double'),
     'double': TypeData(clazz='Primitive', dart_type='num'),
 
     'any': TypeData(clazz='Primitive', dart_type='Object', native_type='ScriptValue', requires_v8_scope=True),
     'Array': TypeData(clazz='Primitive', dart_type='List'),
-    'custom': TypeData(clazz='Primitive', dart_type='Dynamic'),
+    'custom': TypeData(clazz='Primitive', dart_type='dynamic'),
     'Date': TypeData(clazz='Primitive', dart_type='Date', native_type='double'),
     'DOMObject': TypeData(clazz='Primitive', dart_type='Object', native_type='ScriptValue'),
     'DOMString': TypeData(clazz='Primitive', dart_type='String', native_type='String'),
     # TODO(vsm): This won't actually work until we convert the Map to
     # a native JS Map for JS DOM.
     'Dictionary': TypeData(clazz='Primitive', dart_type='Map', requires_v8_scope=True),
     # TODO(sra): Flags is really a dictionary: {create:bool, exclusive:bool}
     # http://dev.w3.org/2009/dap/file-system/file-dir-sys.html#the-flags-interface
     'Flags': TypeData(clazz='Primitive', dart_type='Object'),
     'DOMTimeStamp': TypeData(clazz='Primitive', dart_type='int', native_type='unsigned long long'),
     'object': TypeData(clazz='Primitive', dart_type='Object', native_type='ScriptValue'),
     'ObjectArray': TypeData(clazz='Primitive', dart_type='List'),
     'PositionOptions': TypeData(clazz='Primitive', dart_type='Object'),
     # TODO(sra): Come up with some meaningful name so that where this appears in
     # the documentation, the user is made aware that only a limited subset of
     # serializable types are actually permitted.
-    'SerializedScriptValue': TypeData(clazz='Primitive', dart_type='Dynamic'),
+    'SerializedScriptValue': TypeData(clazz='Primitive', dart_type='dynamic'),
     # TODO(sra): Flags is really a dictionary: {create:bool, exclusive:bool}
     # http://dev.w3.org/2009/dap/file-system/file-dir-sys.html#the-flags-interface
     'WebKitFlags': TypeData(clazz='Primitive', dart_type='Object'),
 
     'sequence': TypeData(clazz='Primitive', dart_type='List'),
     'void': TypeData(clazz='Primitive', dart_type='void'),
 
     'CSSRule': TypeData(clazz='Interface', conversion_includes=['CSSImportRule']),
     'DOMException': TypeData(clazz='Interface', native_type='DOMCoreException'),
     'DOMStringMap': TypeData(clazz='Interface', dart_type='Map<String, String>'),
     'DOMWindow': TypeData(clazz='Interface', custom_to_dart=True),
     'Document': TypeData(clazz='Interface', merged_interface='HTMLDocument'),
     'Element': TypeData(clazz='Interface', merged_interface='HTMLElement',
         custom_to_dart=True),
     'EventListener': TypeData(clazz='Interface', custom_to_native=True),
     'EventTarget': TypeData(clazz='Interface', custom_to_native=True),
     'HTMLDocument': TypeData(clazz='Interface', merged_into='Document'),
     'HTMLElement': TypeData(clazz='Interface', merged_into='Element',
         custom_to_dart=True),
-    'IDBAny': TypeData(clazz='Interface', dart_type='Dynamic', custom_to_native=True),
-    'IDBKey': TypeData(clazz='Interface', dart_type='Dynamic', custom_to_native=True),
+    'IDBAny': TypeData(clazz='Interface', dart_type='dynamic', custom_to_native=True),
+    'IDBKey': TypeData(clazz='Interface', dart_type='dynamic', custom_to_native=True),
     'MutationRecordArray': TypeData(clazz='Interface',  # C++ pass by pointer.
         native_type='MutationRecordArray', dart_type='List<MutationRecord>'),
     'StyleSheet': TypeData(clazz='Interface', conversion_includes=['CSSStyleSheet']),
     'SVGElement': TypeData(clazz='Interface', custom_to_dart=True),
 
     'ClientRectList': TypeData(clazz='Interface',
         item_type='ClientRect', suppress_interface=True),
     'CSSRuleList': TypeData(clazz='Interface',
         item_type='CSSRule', suppress_interface=True),
     'CSSValueList': TypeData(clazz='Interface',
@@ skipping 117 matching lines @@
       else:
         dart_interface_name = type_name
       return InterfaceIDLTypeInfo(type_name, type_data, dart_interface_name,
                                   self)
 
     if type_data.clazz == 'SVGTearOff':
       return SVGTearOffIDLTypeInfo(type_name, type_data, self)
 
     class_name = '%sIDLTypeInfo' % type_data.clazz
     return globals()[class_name](type_name, type_data)