Custom native class spec for Console.

client/dom/scripts/dartgenerator.py

 #!/usr/bin/python
 # Copyright (c) 2011, 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 generates Dart APIs from the IDL database."""
 
 import emitter
 import idlnode
 import logging
@@ skipping 83 matching lines @@
     ])
 
 #
 # Custom getters that must be implemented by hand.
 #
 _custom_getters = set([
     ('DOMWindow', 'localStorage'),
     ])
 
 #
+# Custom native specs for the Frog dom.
+#
+_frog_dom_custom_native_specs = {
+    'Console': '=console',      # Decorate the singleton Console object.
+    'DOMWindow': '@*DOMWindow', # DOMWindow aliased with global scope.
+}
+
+#
 # Publically visible types common across all supported browsers.
 #
 _BROWSER_SHARED_TYPES = [
         'Attr',
         'CDATASection',
         'CSSFontFaceRule',
         'CSSImportRule',
         'CSSMediaRule',
         'CSSPageRule',
         'CSSRule',
@@ skipping 432 matching lines @@
       lib_file_path -- filename for generated .lib file, None if not required.
       lib_template -- template file in this directory for generated lib file.
     """
 
     self._emitters = multiemitter.MultiEmitter()
     self._database = database
     self._output_dir = output_dir
     self._dart_callback_file_paths = []
 
     self._StartGenerateInterfaceLibrary()
-    self._StartGenerateJavaScriptMonkeyImpl(database, output_dir)

[Emily Fortuna, 2011/12/06 23:23:00]

(thumbs up!)

+    self._StartGenerateJavaScriptMonkeyImpl(output_dir)
     self._StartGenerateWrappingImpl(output_dir)
-    self._StartGenerateFrogImpl(database, output_dir)
+    self._StartGenerateFrogImpl(output_dir)
 
     # Render all interfaces into Dart and save them in files.
     dart_file_paths = []
     processed_interfaces = []
     for interface in database.GetInterfaces():
 
       super_interface = None
       super_name = interface.id
 
       if not _MatchSourceFilter(source_filter, interface):
@@ skipping 435 matching lines @@
             result.add(attr.id)
           for op in parent_interface.operations:
             result.add(op.id)
           WalkParentChain(parent_interface)
 
     result = set()
     WalkParentChain(interface)
     return result;
 
 
-  def _StartGenerateFrogImpl(self, database, output_dir):
+  def _StartGenerateFrogImpl(self, output_dir):
     """Prepared for generating frog implementation.
     """
     self._interface_names_with_subtypes = set()
-    for interface in database.GetInterfaces():
+    for interface in self._database.GetInterfaces():
       for parent in interface.parents:
         self._interface_names_with_subtypes.add(parent.type.id)
 
   def _MakeFrogImplInterfaceGenerator(self,
                                       interface,
                                       common_prefix,
                                       super_interface_name,
                                       source_filter):
     """."""
     interface_name = interface.id
     dart_frog_file_path = self.FilePathForFrogImpl(interface_name)
 
     self._dart_frog_file_paths.append(dart_frog_file_path)
 
     dart_code = self._emitters.FileEmitter(dart_frog_file_path)
     dart_code.Emit(
         ''.join(open('template_frog_impl.darttemplate').readlines()))
     return FrogInterfaceGenerator(interface, super_interface_name,
                                   self._interface_names_with_subtypes,
                                   dart_code)
 
 
-  def _StartGenerateJavaScriptMonkeyImpl(self, database, output_dir):
+  def _StartGenerateJavaScriptMonkeyImpl(self, output_dir):
     """Generate a JavaScript implementation that is coherent with
     generated Dart APIs.
     """
-    self._ComputeInheritanceClosure(database)
+    self._ComputeInheritanceClosure()
     js_file_name = os.path.join(output_dir, 'monkey_dom.js')
     code = self._emitters.FileEmitter(js_file_name)
 
     template = ''.join(open('template_monkey_dom.js').readlines())
 
     (self._monkey_global_code,
      self._monkey_init_sequence) = code.Emit(template)
 
     self._monkey_init_sequence.Emit('var $TEMP;\n', TEMP='_')
-    self._protomap = self._GenerateProtoMap(database)
+    self._protomap = self._GenerateProtoMap()
 
     _logger.info('Started Generating %s' % js_file_name)
 
   def _MakeMonkeyInterfaceGenerator(self, interface):
     """Generate JavaScript patch code to match DartC output.
     """
     return MonkeyInterfaceGenerator(self,
                                     interface,
                                     self._monkey_global_code,
                                     self._monkey_init_sequence)
 
-  def _ComputeInheritanceClosure(self, database):
+  def _ComputeInheritanceClosure(self):
     def Collect(interface, seen, collected):
       name = interface.id
       if '<' in name:
         # TODO(sra): Handle parameterized types.
         return
       if not name in seen:
         seen.add(name)
         collected.append(name)
         for parent in interface.parents:
           # TODO(sra): Handle parameterized types.
           if not '<' in parent.type.id:
-            if database.HasInterface(parent.type.id):
-              Collect(database.GetInterface(parent.type.id), seen, collected)
+            if self._database.HasInterface(parent.type.id):
+              Collect(self._database.GetInterface(parent.type.id),
+                      seen, collected)
 
     self._inheritance_closure = {}
-    for interface in database.GetInterfaces():
+    for interface in self._database.GetInterfaces():
       seen = set()
       collected = []
       Collect(interface, seen, collected)
       self._inheritance_closure[interface.id] = collected
 
   def _AllImplementedInterfaces(self, interface):
     """Returns a list of the names of all interfaces implemented by 'interface'.
     List includes the name of 'interface'.
     """
     return self._inheritance_closure[interface.id]
 
-  def _GenerateProtoMap(self, database):
+  def _GenerateProtoMap(self):
     """Determine which DOM type prototypes can be obtained
     from window properties.
     """
     window = None
-    for interface in database.GetInterfaces():
+    for interface in self._database.GetInterfaces():
       if interface.id == 'DOMWindow':
         window = interface
     prototype_table = {}
     boring_type_ids = set(['bool', 'int', 'Number', 'String'])
     if window:
       for attr in window.attributes:
         if attr.is_fc_getter:
           if attr.type.id not in boring_type_ids:
             prototype_table[attr.type.id] = [attr.id]
 
@@ skipping 1151 matching lines @@
       extends = " extends " + base
     else:
       extends = ""
 
     if interface_name in _constructable_types.keys():
       parameters = _constructable_types[interface_name]
       constructor = '  %s(%s) native;\n\n' % (interface_name, parameters)
     else:
       constructor = ''
 
-    # Is the type's constructor accessible from the global scope? If so, we can
-    # directly patch the prototype.  We don't really want to do this yet because
-    # the dynamic patching mechanism is tricky and we want to test it a lot.
-    # But patching is currently broken on FireFox for non-leaf types, so 'hide'
-    # only the leaf types.
-    is_hidden = interface_name not in _BROWSER_SHARED_TYPES
-    if interface_name not in self._interfaces_with_subtypes:
-      is_hidden = True
+    if interface_name in _frog_dom_custom_native_specs:
+      native_spec = _frog_dom_custom_native_specs[interface_name]
+    else:
+      # Is the type's constructor accessible from the global scope? If so, we
+      # can directly patch the prototype.  We don't really want to do this yet
+      # because the dynamic patching mechanism is tricky and we want to test it
+      # a lot.  But patching is currently broken on FireFox for non-leaf types,
+      # so 'hide' only the leaf types.
+      is_hidden = interface_name not in _BROWSER_SHARED_TYPES
+      if interface_name not in self._interfaces_with_subtypes:
+        is_hidden = True
 
-    # Compiler needs to know window is aliased with global scope.
-    global_marker = '@' if interface_name == 'DOMWindow' else ''
+      native_spec = '*' if is_hidden else ''
+      native_spec += interface_name
 
     (self._members_emitter, self._base_emitter) = self._dart_code.Emit(
         '\n'
-        'class $CLASS$BASE native "$SPLAT$HIDDEN$CLASS" {\n'
+        'class $CLASS$BASE native "$NATIVE" {\n'
         '$CONSTRUCTOR$!MEMBERS'
         '$!ADDITIONS'
         '}\n',
         CLASS=self._class_name, BASE=extends,
         INTERFACE=interface_name, CONSTRUCTOR=constructor,
-        SPLAT=global_marker,
-        HIDDEN='*' if is_hidden else '')
+        NATIVE=native_spec)
 
     if not base:
       # Emit shared base functionality here as we have no common base type.
       self._base_emitter.Emit(
           '\n'
           '  var dartObjectLocalStorage;\n'
           '\n'
           '  String get typeName() native;\n')
 
   def _ImplClassName(self, type_name):
@@ skipping 72 matching lines @@
     Arguments:
       info: An OperationInfo object.
     """
     # TODO(vsm): Handle overloads.
     self._members_emitter.Emit(
         '\n'
         '  $TYPE $NAME($ARGS) native;\n',
         TYPE=info.type_name,
         NAME=info.name,
         ARGS=info.arg_implementation_declaration)