Can now correctly add documentation to constructors.

tools/dom/scripts/htmldartgenerator.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
 from generator import AnalyzeOperation, ConstantOutputOrder, \
     DartDomNameOfAttribute, FindMatchingAttribute, IsDartCollectionType, \
-    IsPureInterface, TypeOrNothing
+    IsPureInterface, TypeOrNothing, GetAnnotationsAndComments, \
+    FormatAnnotationsAndComments
 
 # Types that are accessible cross-frame in a limited fashion.
 # In these cases, the base type (e.g., WindowBase) provides restricted access
 # while the subtype (e.g., Window) provides full access to the
 # corresponding objects if there are from the same frame.
 _secure_base_types = {
   'Window': 'WindowBase',
   'Location': 'LocationBase',
   'History': 'HistoryBase',
 }
 
 
 class HtmlDartGenerator(object):
   def __init__(self, interface, options):
     self._database = options.database
     self._interface = interface
     self._type_registry = options.type_registry
     self._interface_type_info = self._type_registry.TypeInfo(self._interface.id)
     self._renamer = options.renamer
+    self._library_name = self._renamer.GetLibraryName(self._interface)
 
   def EmitSupportCheck(self):
     if self.HasSupportCheck():
       support_check = self.GetSupportCheck()
       self._members_emitter.Emit('\n'
           '  /// Checks if this type is supported on the current platform.\n'
           '  static bool get supported => $SUPPORT_CHECK;\n',
           SUPPORT_CHECK=support_check)
 
   def EmitEventGetter(self, events_class_name):
@@ skipping 267 matching lines @@
     for constructor_info in constructors:
       self._AddConstructor(
           constructor_info, factory_name, factory_constructor_name)
 
     typed_array_type = None
     for interface in self._database.Hierarchy(self._interface):
       type_info = self._type_registry.TypeInfo(interface.id)
       if type_info.is_typed_array():
         typed_array_type = type_info.list_item_type()
         break
+
+    annotations = FormatAnnotationsAndComments(
+        GetAnnotationsAndComments(self._library_name, self._interface.id,
+                                  self._interface.id), '  ')
+
+    fromListAnnotations = FormatAnnotationsAndComments(
+        GetAnnotationsAndComments(self._library_name, self._interface.id,
+                                  'fromList'), '  ')
+
+    fromBufferAnnotations = FormatAnnotationsAndComments(
+        GetAnnotationsAndComments(self._library_name, self._interface.id,
+                                  'fromBuffer'), '  ')
+
     if typed_array_type:
       self._members_emitter.Emit(
-          '\n'
-          '  factory $CTOR(int length) =>\n'
+          '\n  $(ANNOTATIONS)factory $CTOR(int length) =>\n'
           '    $FACTORY.create$(CTOR)(length);\n'
-          '\n'
-          '  factory $CTOR.fromList(List<$TYPE> list) =>\n'
+          '\n  $(LIST_ANNOTATIONS)factory $CTOR.fromList(List<$TYPE> list) =>\n'
           '    $FACTORY.create$(CTOR)_fromList(list);\n'
-          '\n'
-          '  factory $CTOR.fromBuffer(ArrayBuffer buffer, '
+          '\n  $(BUFFER_ANNOTATIONS)factory $CTOR.fromBuffer(ArrayBuffer buffer, '
               '[int byteOffset, int length]) => \n'
           '    $FACTORY.create$(CTOR)_fromBuffer(buffer, byteOffset, length);\n',
         CTOR=self._interface.id,
+        ANNOTATIONS=annotations,
+        LIST_ANNOTATIONS=fromListAnnotations,
+        BUFFER_ANNOTATIONS=fromBufferAnnotations,
         TYPE=self._DartType(typed_array_type),
         FACTORY=factory_name)
 
   def _AddConstructor(self,
       constructor_info, factory_name, factory_constructor_name):
     if self.GenerateCustomFactory(constructor_info):
       return
 
-    self._members_emitter.Emit('\n  @DocsEditable');
+    annotations = FormatAnnotationsAndComments(
+        GetAnnotationsAndComments(self._library_name, self._interface.id,
+                                  self._interface.id), '  ')
 
     if not factory_constructor_name:
       factory_constructor_name = '_create'
       factory_parameters = constructor_info.ParametersAsArgumentList()
       has_factory_provider = True
     else:
       factory_parameters = ', '.join(constructor_info.factory_parameters)
       has_factory_provider = False
 
     if constructor_info.pure_dart_constructor:
       # TODO(antonm): use common dispatcher generation for this case as well.
       has_optional = any(param_info.is_optional
           for param_info in constructor_info.param_infos)
 
       if not has_optional:
         self._members_emitter.Emit(
-            '\n'
-            '  factory $CTOR($PARAMS) => '
+            '\n  $(ANNOTATIONS)'
+            'factory $CTOR($PARAMS) => '
             '$FACTORY.$CTOR_FACTORY_NAME($FACTORY_PARAMS);\n',
             CTOR=constructor_info._ConstructorFullName(self._DartType),
             PARAMS=constructor_info.ParametersDeclaration(self._DartType),
             FACTORY=factory_name,
+            ANNOTATIONS=annotations,
             CTOR_FACTORY_NAME=factory_constructor_name,
             FACTORY_PARAMS=factory_parameters)
       else:
         if has_factory_provider:
           dispatcher_emitter = self._members_emitter.Emit(
-              '\n'
-              '  factory $CTOR($PARAMS) {\n'
+              '\n  $(ANNOTATIONS)'
+              'factory $CTOR($PARAMS) {\n'
               '$!DISPATCHER'
               '    return $FACTORY._create($FACTORY_PARAMS);\n'
               '  }\n',
               CTOR=constructor_info._ConstructorFullName(self._DartType),
               PARAMS=constructor_info.ParametersDeclaration(self._DartType),
               FACTORY=factory_name,
+              ANNOTATIONS=annotations,
               FACTORY_PARAMS=constructor_info.ParametersAsArgumentList())
 
           for index, param_info in enumerate(constructor_info.param_infos):
             if param_info.is_optional:
               dispatcher_emitter.Emit(
                 '    if (!?$OPT_PARAM_NAME) {\n'
                 '      return $FACTORY._create($FACTORY_PARAMS);\n'
                 '    }\n',
                 OPT_PARAM_NAME=param_info.name,
                 FACTORY=factory_name,
                 FACTORY_PARAMS=constructor_info.ParametersAsArgumentList(index))
         else:
           inits = self._members_emitter.Emit(
-              '\n'
-              '  factory $CONSTRUCTOR($PARAMS) {\n'
+              '\n  $(ANNOTATIONS)'
+              'factory $CONSTRUCTOR($PARAMS) {\n'
               '    var e = $FACTORY.$CTOR_FACTORY_NAME($FACTORY_PARAMS);\n'
               '$!INITS'
               '    return e;\n'
               '  }\n',
               CONSTRUCTOR=constructor_info._ConstructorFullName(self._DartType),
+              ANNOTATIONS=annotations,
               FACTORY=factory_name,
               CTOR_FACTORY_NAME=factory_constructor_name,
               PARAMS=constructor_info.ParametersDeclaration(self._DartType),
               FACTORY_PARAMS=factory_parameters)
 
           for index, param_info in enumerate(constructor_info.param_infos):
             if param_info.is_optional:
               inits.Emit('    if ($E != null) e.$E = $E;\n', E=param_info.name)
     else:
       def GenerateCall(
           stmts_emitter, call_emitter,
           version, signature_index, argument_count):
         name = emitter.Format('_create_$VERSION', VERSION=version)
         call_emitter.Emit('$FACTORY.$NAME($FACTORY_PARAMS)',
             FACTORY=factory_name,
             NAME=name,
             FACTORY_PARAMS= \
                 constructor_info.ParametersAsArgumentList(argument_count))
         self.EmitStaticFactoryOverload(
             constructor_info, name,
             constructor_info.idl_args[signature_index][:argument_count])
 
       def IsOptional(signature_index, argument):
         return self.IsConstructorArgumentOptional(argument)
 
       self._GenerateOverloadDispatcher(
           constructor_info.idl_args,
           False,
           [info.name for info in constructor_info.param_infos],
-          emitter.Format('factory $CTOR($PARAMS)',
+          emitter.Format('$(ANNOTATIONS)factory $CTOR($PARAMS)',
             CTOR=constructor_info._ConstructorFullName(self._DartType),
+            ANNOTATIONS=annotations,
             PARAMS=constructor_info.ParametersDeclaration(self._DartType)),
           GenerateCall,
           IsOptional)
 
   def EmitHelpers(self, base_class):
     pass
 
   def DeclareAttribute(self, attribute, type_name, attr_name, read_only):
     """ Declares an attribute but does not include the code to invoke it.
     """
@@ skipping 92 matching lines @@
         walk(interface.parents)
       else:
         walk(interface.parents[1:])
     return result
 
   def _DartType(self, type_name):
     return self._type_registry.DartType(type_name)
 
   def _IsPrivate(self, name):
     return name.startswith('_')