Add custom annotations to some APIs for native tree shaking.

sdk/lib/html/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 os
@@ skipping 530 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)
+    annotations = self._Annotations(attribute.type.id, attribute.id)
     self.EmitAttributeDocumentation(attribute)
     if not read_only:
       self._members_emitter.Emit(
-          '\n  $TYPE $NAME;'
+          '\n  $ANNOTATIONS$TYPE $NAME;'
           '\n',
+          ANNOTATIONS=annotations,
           NAME=DartDomNameOfAttribute(attribute),
           TYPE=output_type)
     else:
       self._members_emitter.Emit(
-          '\n  final $TYPE $NAME;'
+          '\n  $(ANNOTATIONS)final $TYPE $NAME;'
           '\n',
+          ANNOTATIONS=annotations,
           NAME=DartDomNameOfAttribute(attribute),
           TYPE=output_type)
 
   def _AddAttributeUsingProperties(self, attribute, html_name, read_only):
     self._AddRenamingGetter(attribute, html_name)
     if not read_only:
       self._AddRenamingSetter(attribute, html_name)
 
   def _AddInterfaceAttribute(self, attribute):
     self._members_emitter.Emit(
@@ skipping 81 matching lines @@
       # Any conversions needed?
       self._AddOperationWithConversions(info, html_name)
     else:
       self._AddDirectNativeOperation(info, html_name)
 
   def _AddDirectNativeOperation(self, info, html_name):
     # Do we need a native body?
     if html_name != info.declared_name:
       return_type = self.SecureOutputType(info.type_name)
 
-      operation_emitter = self._members_emitter.Emit('$!SCOPE',
+      operation_emitter = self._members_emitter.Emit(
+          '$!SCOPE',
           MODIFIERS='static ' if info.IsStatic() else '',
+          ANNOTATIONS=self._Annotations(info.type_name, info.declared_name),
           TYPE=return_type,
           HTML_NAME=html_name,
           NAME=info.declared_name,
           PARAMS=info.ParametersDeclaration(self._NarrowInputType))
 
       operation_emitter.Emit(
           '\n'
-          #'  // @native("$NAME")\n;'
-          '  $MODIFIERS$TYPE $(HTML_NAME)($PARAMS) native "$NAME";\n')
+          '  $ANNOTATIONS'
+          '$MODIFIERS$TYPE $(HTML_NAME)($PARAMS) native "$NAME";\n')
     else:
       self._members_emitter.Emit(
           '\n'
-          '  $MODIFIERS$TYPE $NAME($PARAMS) native;\n',
+          '  $ANNOTATIONS$MODIFIERS$TYPE $NAME($PARAMS) native;\n',
           MODIFIERS='static ' if info.IsStatic() else '',
+          ANNOTATIONS=self._Annotations(info.type_name, info.declared_name),
           TYPE=self.SecureOutputType(info.type_name),
           NAME=info.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)
     if output_conversion:
@@ skipping 81 matching lines @@
       if output_conversion:
         call = '%s(%s)' % (output_conversion.function_name, call)
 
       if operation.type.id == 'void':
         call_emitter.Emit('$(INDENT)$CALL;\n$(INDENT)return;\n',
                           CALL=call)
       else:
         call_emitter.Emit('$(INDENT)return $CALL;\n', CALL=call)
 
       self._members_emitter.Emit(
-          '  $MODIFIERS$TYPE$TARGET($PARAMS) native "$NATIVE";\n',
+          '  $MODIFIERS$ANNOTATIONS$TYPE$TARGET($PARAMS) native "$NATIVE";\n',
           MODIFIERS='static ' if info.IsStatic() else '',
+          ANNOTATIONS=self._Annotations(info.type_name, info.declared_name),
           TYPE=TypeOrNothing(native_return_type),
           TARGET=target,
           PARAMS=', '.join(target_parameters),
           NATIVE=info.declared_name)
 
     def GenerateChecksAndCall(operation, argument_count):
       checks = []
       for i in range(0, argument_count):
         argument = operation.arguments[i]
         parameter_name = parameter_names[i]
@@ skipping 63 matching lines @@
     return FindConversion(idl_type, 'get', self._interface.id, member)
 
   def _InputConversion(self, idl_type, member):
     return FindConversion(idl_type, 'set', self._interface.id, member)
 
   def _HasCustomImplementation(self, member_name):
     member_name = '%s.%s' % (self._interface_type_info.interface_name(),
                              member_name)
     return member_name in _js_custom_members
 
+  def _Annotations(self, idl_type, member_name):
+    annotations = FindAnnotations(idl_type, self._interface.id, member_name)
+    if annotations:
+      return '%s\n  ' % annotations
+    else:
+      return ''
+
   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)
 
   def _FindShadowedAttribute(self, attr):
@@ skipping 95 matching lines @@
       'svg': DartLibrary('svg', template_loader, library_type, output_dir),
       'html': DartLibrary('html', 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)