Adding annotations for native types of type Object or dynamic.

tools/dom/scripts/systemhtml.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
+import logging
 import monitored
 import os
+import re
 from generator import *
 from htmldartgenerator import *
 
+_logger = logging.getLogger('systemhtml')
+
 HTML_LIBRARY_NAMES = ['chrome', 'html', 'indexed_db', 'svg',
                       'web_audio', 'web_gl', 'web_sql']
 
 _js_custom_members = monitored.Set('systemhtml._js_custom_members', [
     'AudioBufferSourceNode.start',
     'AudioBufferSourceNode.stop',
     'AudioContext.createGain',
     'AudioContext.createScriptProcessor',
     'CanvasRenderingContext2D.drawImage',
     'CanvasRenderingContext2D.lineDashOffset',
@@ skipping 762 matching lines @@
 
     # If the type has a conversion we need a getter or setter to contain the
     # conversion code.
     if (self._OutputConversion(attribute.type.id, attribute.id) or
         self._InputConversion(attribute.type.id, attribute.id)):
       self._AddAttributeUsingProperties(attribute, html_name, read_only)
       return
 
     output_type = self.SecureOutputType(attribute.type.id)
     input_type = self._NarrowInputType(attribute.type.id)
-    metadata = self._Metadata(attribute.type.id, attribute.id)
+    metadata = self._Metadata(attribute.type.id, attribute.id, output_type)
     rename = self._RenamingAnnotation(attribute.id, html_name)
     if not read_only:
       self._members_emitter.Emit(
           '\n  $RENAME$METADATA$TYPE $NAME;'
           '\n',
           RENAME=rename,
           METADATA=metadata,
           NAME=html_name,
           TYPE=output_type)
     else:
@@ skipping 52 matching lines @@
         HTML_NAME=html_name,
         NAME=attr.id,
         TYPE=self._NarrowInputType(attr.type.id))
 
   def _AddConvertingGetter(self, attr, html_name, conversion):
     self._members_emitter.Emit(
         '\n  $RETURN_TYPE get $HTML_NAME => $CONVERT(this._get_$(HTML_NAME));'
         "\n  @JSName('$NAME')"
         '\n  $(METADATA)final $NATIVE_TYPE _get_$HTML_NAME;'
         '\n',
-        METADATA=self._Metadata(attr.type.id, html_name),
+        METADATA=self._Metadata(attr.type.id, html_name, conversion.input_type),
         CONVERT=conversion.function_name,
         HTML_NAME=html_name,
         NAME=attr.id,
         RETURN_TYPE=conversion.output_type,
         NATIVE_TYPE=conversion.input_type)
 
   def _AddConvertingSetter(self, attr, html_name, conversion):
     self._members_emitter.Emit(
         # TODO(sra): Use metadata to provide native name.
         '\n  void set $HTML_NAME($INPUT_TYPE value) {'
@@ skipping 28 matching lines @@
       # Any conversions needed?
       self._AddOperationWithConversions(info, html_name)
     else:
       self._AddDirectNativeOperation(info, html_name)
 
   def _AddDirectNativeOperation(self, info, html_name):
     self._members_emitter.Emit(
         '\n'
         '  $RENAME$METADATA$MODIFIERS$TYPE $NAME($PARAMS) native;\n',
         RENAME=self._RenamingAnnotation(info.declared_name, html_name),
-        METADATA=self._Metadata(info.type_name, info.declared_name),
+        METADATA=self._Metadata(info.type_name, info.declared_name,
+            self.SecureOutputType(info.type_name)),
         MODIFIERS='static ' if info.IsStatic() else '',
         TYPE=self.SecureOutputType(info.type_name),
         NAME=html_name,
         PARAMS=info.ParametersDeclaration(self._NarrowInputType))
 
   def _AddOperationWithConversions(self, info, html_name):
     # Assert all operations have same return type.
     assert len(set([op.type.id for op in info.operations])) == 1
     output_conversion = self._OutputConversion(info.type_name,
                                                info.declared_name)
@@ skipping 61 matching lines @@
       call = '%s(%s)' % (target, argument_list)
 
       if output_conversion:
         call = '%s(%s)' % (output_conversion.function_name, call)
 
       call_emitter.Emit(call)
 
       self._members_emitter.Emit(
           '  $RENAME$METADATA$MODIFIERS$TYPE$TARGET($PARAMS) native;\n',
           RENAME=self._RenamingAnnotation(info.declared_name, target),
-          METADATA=self._Metadata(info.type_name, info.declared_name),
+          METADATA=self._Metadata(info.type_name, info.declared_name, None),
           MODIFIERS='static ' if info.IsStatic() else '',
           TYPE=TypeOrNothing(native_return_type),
           TARGET=target,
           PARAMS=', '.join(target_parameters))
 
     declaration = '%s%s%s %s(%s)' % (
-        self._Metadata(info.type_name, info.declared_name),
+        self._Metadata(info.type_name, info.declared_name, return_type),
         'static ' if info.IsStatic() else '',
         return_type,
         html_name,
         info.ParametersDeclaration(InputType))
     self._GenerateDispatcherBody(
         info,
         operations,
         declaration,
         GenerateCall,
         lambda _, argument: IsOptional(argument),
@@ skipping 27 matching lines @@
 
   def _HasCustomImplementation(self, member_name):
     member_name = '%s.%s' % (self._interface.doc_js_name, member_name)
     return member_name in _js_custom_members
 
   def _RenamingAnnotation(self, idl_name, member_name):
     if member_name != idl_name:
       return  "@JSName('%s')\n  " % idl_name
     return ''
 
-  def _Metadata(self, idl_type, idl_member_name, indent='  '):
+  def _Metadata(self, idl_type, idl_member_name, dart_type, indent='  '):
     anns = self._metadata.GetDart2JSMetadata(
         idl_type, self._library_name, self._interface, idl_member_name)
 
     if not self._metadata.AnyConversionAnnotations(
         idl_type, self._interface.id, idl_member_name):
       return_type = self.SecureOutputType(idl_type)
       native_type = self._NarrowToImplementationType(idl_type)
       if native_type != return_type:
         anns = anns + [
           "@Returns('%s')" % native_type,
           "@Creates('%s')" % native_type,
         ]
+    if dart_type == 'dynamic' or dart_type == 'Object':
+      def js_type_annotation(ann):
+        return re.search('^@.*Returns', ann) or re.search('^@.*Creates', ann)
+      if not filter(js_type_annotation, anns):
+        _logger.warn('Member with wildcard native type: %s.%s' %
+            (self._interface.id, idl_member_name))
+
     return self._metadata.FormatMetadata(anns, indent);
 
   def CustomJSMembers(self):
     return _js_custom_members
 
   def _NarrowToImplementationType(self, type_name):
     return self._type_registry.TypeInfo(type_name).narrow_dart_type()
 
   def _NarrowInputType(self, type_name):
     return self._NarrowToImplementationType(type_name)
@@ skipping 97 matching lines @@
     for library_name in libraries:
       self._libraries[library_name] = DartLibrary(
           library_name, template_loader, library_type, output_dir)
 
   def AddFile(self, basename, library_name, path):
     self._libraries[library_name].AddFile(path)
 
   def Emit(self, emitter, auxiliary_dir):
     for lib in self._libraries.values():
       lib.Emit(emitter, auxiliary_dir)