Automatically generate most constructors

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 207 matching lines @@
     # against dart:dom to load in a worker isolate.
     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 AnalyzeOperation(interface, operations):
-  """Makes operation calling convention decision for a set of overloads.
 
-  Returns: An OperationInfo object.
-  """
-
-  # Zip together arguments from each overload by position, then convert
-  # to a dart argument.
-
+# 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):
     typeIds = sorted(set(arg.type.id for arg in args))
     if len(typeIds) == 1:
       return typeIds[0]
     else:
       return TypeName(typeIds, interface)
 
-  # Given a list of overloaded arguments, render a dart argument.
-  def DartArg(args):
-    filtered = filter(None, args)
-    optional = any(not arg or arg.is_optional for arg in args)
-    type = OverloadedType(filtered)
-    name = OverloadedName(filtered)
-    if optional:
-      return (name, type, 'null')
-    else:
-      return (name, type, None)
+  filtered = filter(None, args)
+  optional = any(not arg or arg.is_optional for arg in args)
+  type = OverloadedType(filtered)
+  name = OverloadedName(filtered)
+  if optional:
+    return (name, type, 'null')
+  else:
+    return (name, type, None)
 
-  args = map(lambda *args: DartArg(args),
+
+def AnalyzeOperation(interface, operations):
+  """Makes operation calling convention decision for a set of overloads.
+
+  Returns: An OperationInfo object.
+  """
+
+  # Zip together arguments from each overload by position, then convert
+  # to a dart argument.
+  args = map(lambda *args: _DartArg(args, interface),
              *(op.arguments for op in operations))
 
   info = OperationInfo()
   info.overloads = operations
   info.declared_name = operations[0].id
   info.name = operations[0].ext_attrs.get('DartName', info.declared_name)
   info.js_name = info.declared_name
   info.type_name = operations[0].type.id   # TODO: widen.
   info.arg_infos = args
   return info
 
+
+def AnalyzeConstructor(interface):
+  """Returns an OperationInfo object for the constructor.
+
+  Returns None if the interface has no Constructor.
+  """
+  def GetArgs(func_value):
+    return map(lambda arg: _DartArg([arg], interface), func_value.arguments)
+
+  if 'Constructor' in interface.ext_attrs:
+    name = None
+    func_value = interface.ext_attrs.get('Constructor')
+    if func_value:
+      # [Constructor(param,...)]
+      args = GetArgs(func_value)
+    else: # [Constructor]
+      args = []
+  else:
+    func_value = interface.ext_attrs.get('NamedConstructor')
+    if func_value:
+      name = func_value.id
+      args = GetArgs(func_value)
+    else:
+      return None
+
+  info = OperationInfo()
+  info.overloads = None  # [func_value]
+  info.declared_name = name
+  info.name = name
+  info.js_name = name
+  info.type_name = interface.id
+  info.arg_infos = args
+  return info
+
+
 def RecognizeCallback(interface):
   """Returns the info for the callback method if the interface smells like a
   callback.
   """
   if 'Callback' not in interface.ext_attrs: return None
   handlers = [op for op in interface.operations if op.id == 'handleEvent']
   if not handlers: return None
   if not (handlers == interface.operations): return None
   return AnalyzeOperation(interface, handlers)
 
 def IsDartListType(type):
   return type == 'List' or type.startswith('List<')
 
 def IsDartCollectionType(type):
   return IsDartListType(type)
 
 def FindMatchingAttribute(interface, attr1):
   matches = [attr2 for attr2 in interface.attributes
              if attr1.id == attr2.id
              and attr1.is_fc_getter == attr2.is_fc_getter
              and attr1.is_fc_setter == attr2.is_fc_setter]
   if matches:
     assert len(matches) == 1
     return matches[0]
   return None
 
+
 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.
     type_name: A string, the name of the return type of the operation.
     arg_infos: A list of (name, type, default_value) tuples.
         default_value is None for mandatory arguments.
   """
@@ skipping 253 matching lines @@
 
 original_idl_types = {
 }
 
 def GetIDLTypeInfo(idl_type):
   idl_type_name = original_idl_types.get(idl_type, idl_type.id)
   return GetIDLTypeInfoByName(idl_type_name)
 
 def GetIDLTypeInfoByName(idl_type_name):
   return _idl_type_registry.get(idl_type_name, IDLTypeInfo(idl_type_name))