Exposing native doubles as doubles when they are read-only or method return values.

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
@@ skipping 732 matching lines @@
     if indexed_getter:
       self._members_emitter.Emit(
           '\n'
           '  $TYPE operator[](int index) {\n'
           '    if (JS("bool", "# >>> 0 !== # || # >= #", index,\n'
           '        index, index, length))\n'
           '      throw new RangeError.range(index, 0, length);\n'
           '    return $INDEXED_GETTER;\n'
           '  }',
           INDEXED_GETTER=indexed_getter,
-          TYPE=self.SecureOutputType(element_type))
+          TYPE=self.SecureOutputType(element_type, False, True))
 
     if 'CustomIndexedSetter' in self._interface.ext_attrs:
       self._members_emitter.Emit(
           '\n'
           '  void operator[]=(int index, $TYPE value) {'
           ' JS("void", "#[#] = #", this, index, value); }',
           TYPE=self._NarrowInputType(element_type))
     else:
       self._members_emitter.Emit(
           '\n'
@@ skipping 24 matching lines @@
       if read_only:
         if attribute.type.id == super_attribute.type.id:
           # Compatible attribute, use the superclass property.  This works
           # because JavaScript will do its own dynamic dispatch.
           self._members_emitter.Emit(
               '\n'
               '  // Use implementation from $SUPER.\n'
               '  // final $TYPE $NAME;\n',
               SUPER=super_attribute_interface,
               NAME=html_name,
-              TYPE=self.SecureOutputType(attribute.type.id))
+              TYPE=self.SecureOutputType(attribute.type.id, False, read_only))
           return
       self._members_emitter.Emit('\n  // Shadowing definition.')
       self._AddAttributeUsingProperties(attribute, html_name, read_only)
       return
 
     # 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)
+    output_type = self.SecureOutputType(attribute.type.id, False, read_only)
     input_type = self._NarrowInputType(attribute.type.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,
@@ skipping 109 matching lines @@
       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,
             self.SecureOutputType(info.type_name)),
         MODIFIERS='static ' if info.IsStatic() else '',
-        TYPE=self.SecureOutputType(info.type_name),
+        TYPE=self.SecureOutputType(info.type_name, False, True),
         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)
     if output_conversion:
       return_type = output_conversion.output_type
@@ skipping 84 matching lines @@
         operations,
         declaration,
         GenerateCall,
         lambda _, argument: IsOptional(argument),
         can_omit_type_check=lambda type, pos: type == parameter_types[pos])
 
   def _AddInterfaceOperation(self, info, html_name):
     self._members_emitter.Emit(
         '\n'
         '  $TYPE $NAME($PARAMS);\n',
-        TYPE=self.SecureOutputType(info.type_name),
+        TYPE=self.SecureOutputType(info.type_name, False, True),
         NAME=info.name,
         PARAMS=info.ParametersDeclaration(self._NarrowInputType))
 
 
   def _OperationRequiresConversions(self, operation):
     return (self._OperationRequiresOutputConversion(operation) or
             self._OperationRequiresInputConversions(operation))
 
   def _OperationRequiresOutputConversion(self, operation):
     return self._OutputConversion(operation.type.id, operation.id)
@@ skipping 77 matching lines @@
             attr2 = FindMatchingAttribute(interface, attr)
             if attr2:
               return (attr2, parent_interface_name)
 
           return FindInParent(
               self._database.GetInterface(parent_interface_name))
       return (None, None)
 
     return FindInParent(self._interface) if attr else (None, None)
 
-  def _DartType(self, type_name):
-    return self._type_registry.DartType(type_name)
-
 # ------------------------------------------------------------------------------
 
 class DartLibraryEmitter():
   def __init__(self, multiemitter, dart_sources_dir, dart_libraries):
     self._multiemitter = multiemitter
     self._dart_sources_dir = dart_sources_dir
     self._path_to_emitter = {}
     self._dart_libraries = dart_libraries
 
   def FileEmitter(self, basename, library_name, template=None):
@@ skipping 47 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)