Emit static IDL members.

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
 
@@ skipping 644 matching lines @@
       if info.name == 'item':
         # FIXME: item should be renamed to operator[], not removed.
         self._backend.AddOperation(info, '_item')
       return
 
     if not self._shared.IsPrivate(html_name) and not skip_declaration:
       self._members_emitter.Emit('\n  /** @domName $DOMINTERFACE.$DOMNAME */',
           DOMINTERFACE=info.overloads[0].doc_js_interface_name,
           DOMNAME=info.name)
 
-      self._members_emitter.Emit('\n'
-                                 '  $TYPE $NAME($PARAMS);\n',
-                                 TYPE=self._DartType(info.type_name),
-                                 NAME=html_name,
-                                 PARAMS=info.ParametersInterfaceDeclaration(self._DartType))
+      if info.IsStatic():
+        # FIXME: provide a type.
+        self._members_emitter.Emit('\n'
+                                  '  static final $NAME = $IMPL_CLASS_NAME.$NAME;\n',
+                                  IMPL_CLASS_NAME=self._backend.ImplementationClassName(),
+                                  NAME=html_name)
+      else:
+        self._members_emitter.Emit('\n'
+                                  '  $TYPE $NAME($PARAMS);\n',
+                                  TYPE=self._DartType(info.type_name),
+                                  NAME=html_name,
+                                  PARAMS=info.ParametersInterfaceDeclaration(self._DartType))
     self._backend.AddOperation(info, html_name)
 
-  def AddStaticOperation(self, info):
-    self.AddOperation(info, True)
-
   def AddSecondaryOperation(self, interface, info):
     self._backend.SecondaryContext(interface)
     self.AddOperation(info, True)
 
   def FinishInterface(self):
     self._backend.FinishInterface()
 
   def AddConstant(self, constant):
     type = TypeOrNothing(self._DartType(constant.type.id), constant.type.id)
     self._members_emitter.Emit('\n  static const $TYPE$NAME = $VALUE;\n',
@@ skipping 317 matching lines @@
 
 
   def AddOperation(self, info, html_name):
     """
     Arguments:
       info: An OperationInfo object.
     """
     if self._HasCustomImplementation(info.name):
       return
 
-    # FIXME: support static operations.
-    if info.IsStatic():
-      return
-
     # Any conversions needed?
     if any(self._OperationRequiresConversions(op) for op in info.overloads):
       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._NarrowOutputType(info.type_name)
 
       operation_emitter = self._members_emitter.Emit('$!SCOPE',
+          MODIFIERS='static ' if info.IsStatic() else '',
           TYPE=return_type,
           HTML_NAME=html_name,
           NAME=info.declared_name,
           PARAMS=info.ParametersImplementationDeclaration(
               lambda type_name: self._NarrowInputType(type_name)))
 
       operation_emitter.Emit(
           '\n'
           #'  // @native("$NAME")\n;'
-          '  $TYPE $(HTML_NAME)($PARAMS) native "$NAME";\n')
+          '  $MODIFIERS$TYPE $(HTML_NAME)($PARAMS) native "$NAME";\n')
     else:
       self._members_emitter.Emit(
           '\n'
-          '  $TYPE $NAME($PARAMS) native;\n',
+          '  $MODIFIERS$TYPE $NAME($PARAMS) native;\n',
+          MODIFIERS='static ' if info.IsStatic() else '',
           TYPE=self._NarrowOutputType(info.type_name),
           NAME=info.name,
           PARAMS=info.ParametersImplementationDeclaration(
               lambda type_name: self._NarrowInputType(type_name)))
 
   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
     info = info.CopyAndWidenDefaultParameters()
     output_conversion = self._OutputConversion(info.type_name,
                                                info.declared_name)
     if output_conversion:
       return_type = output_conversion.output_type
       native_return_type = output_conversion.input_type
     else:
       return_type = self._NarrowInputType(info.type_name)
       native_return_type = return_type
 
     def InputType(type_name):
       conversion = self._InputConversion(type_name, info.declared_name)
       if conversion:
         return conversion.input_type
       else:
         return self._NarrowInputType(type_name)
 
     body = self._members_emitter.Emit(
         '\n'
-        '  $TYPE $(HTML_NAME)($PARAMS) {\n'
+        '  $MODIFIERS$TYPE $(HTML_NAME)($PARAMS) {\n'
         '$!BODY'
         '  }\n',
+        MODIFIERS='static ' if info.IsStatic() else '',
         TYPE=return_type,
         HTML_NAME=html_name,
         PARAMS=info.ParametersImplementationDeclaration(InputType))
 
     parameter_names = [param_info.name for param_info in info.param_infos]
     parameter_types = [InputType(param_info.dart_type)
                        for param_info in info.param_infos]
     operations = info.operations
 
     method_version = [0]
@@ skipping 148 matching lines @@
   def GenerateLibraries(self, dart_files):
     auxiliary_dir = os.path.relpath(self._auxiliary_dir, self._output_dir)
     self._GenerateLibFile(
         'html_dart2js.darttemplate',
         os.path.join(self._output_dir, 'html_dart2js.dart'),
         dart_files,
         AUXILIARY_DIR=systembase.MassagePath(auxiliary_dir))
 
   def Finish(self):
     pass