record that Gamepad.buttons creates GamepadButtons

tools/dom/scripts/htmldartgenerator.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
 from generator import AnalyzeOperation, ConstantOutputOrder, \
@@ skipping 65 matching lines @@
 
     for attr in sorted(interface.attributes, ConstantOutputOrder):
       if attr.type.id != 'EventHandler' and attr.type.id != 'EventListener':
         self.AddAttribute(attr, declare_only)
 
     # The implementation should define an indexer if the interface directly
     # extends List.
     element_type = None
     requires_indexer = False
     if self._interface_type_info.list_item_type():
-      self.AddIndexer(self._interface_type_info.list_item_type())
+      self.AddIndexer(self._interface_type_info.list_item_type(),
+                      self._interface_type_info.list_item_type_nullable())
     else:
       for parent in self._database.Hierarchy(self._interface):
         if parent == self._interface:
           continue
         parent_type_info = self._type_registry.TypeInfo(parent.id)
         if parent_type_info.list_item_type():
           self.AmendIndexer(parent_type_info.list_item_type())
           break
 
     # Group overloaded operations by name.
@@ skipping 655 matching lines @@
       return
     else:
       template = '\n  $TYPE $NAME($PARAMS);\n'
 
     self._members_emitter.Emit(
              template,
              TYPE=return_type_name,
              NAME=method_name,
              PARAMS=operation.ParametersAsDeclaration(self._DartType))
 
-  def EmitListMixin(self, element_name):
+  def EmitListMixin(self, element_name, nullable):
     # TODO(sra): Use separate mixins for mutable implementations of List<T>.
     # TODO(sra): Use separate mixins for typed array implementations of List<T>.
     template_file = 'immutable_list_mixin.darttemplate'
     has_length = False
     has_length_setter = False
 
     def _HasExplicitIndexedGetter(self):
       return any(op.id == 'getItem' for op in self._interface.operations)
 
     def _HasCustomIndexedGetter(self):
@@ skipping 15 matching lines @@
     has_num_items = any(attr.id == 'numberOfItems'
         for attr in self._interface.attributes)
 
     template = self._template_loader.Load(
         template_file,
         {
           'DEFINE_LENGTH_AS_NUM_ITEMS': not has_length and has_num_items,
           'DEFINE_LENGTH_SETTER': not has_length_setter,
           'USE_NATIVE_INDEXED_GETTER': _HasNativeIndexedGetter(self) or _HasExplicitIndexedGetter(self),
         })
-    self._members_emitter.Emit(template, E=element_name, GETTER=getter_name)
+    if nullable:
+        element_js = element_name + "|Null"
+    else:
+        element_js = element_name
+    self._members_emitter.Emit(template, E=element_name, EJS=element_js,
+                               GETTER=getter_name)
 
   def SecureOutputType(self, type_name, is_dart_type=False,
       can_narrow_type=False):
     """ Converts the type name to the secure type name for return types.
     Arguments:
       can_narrow_type - True if the output type can be narrowed further than
         what would be accepted for input, used to narrow num APIs down to double
         or int.
     """
     if is_dart_type:
@@ skipping 54 matching lines @@
         converted_arguments.append(temp_name)
         param_type = temp_type
         verified_type = temp_type  # verified by assignment in checked mode.
       else:
         converted_arguments.append(info.param_infos[position].name)
         if self._database.HasTypeDef(arg.type.id):
           param_type = 'dynamic'
         else:
           param_type = self._NarrowInputType(arg.type.id)
           # Verified by argument checking on entry to the dispatcher.
-  
+
           verified_type = self._InputType(
               info.param_infos[position].type_id, info)
           # The native method does not need an argument type if we know the type.
           # But we do need the native methods to have correct function types, so
           # be conservative.
           if param_type == verified_type:
             if param_type in ['String', 'num', 'int', 'double', 'bool', 'Object']:
               param_type = 'dynamic'
 
       target_parameters.append(
           '%s%s' % (TypeOrNothing(param_type), param_name))
 
     return target_parameters, converted_arguments
 
   def _InputType(self, type_name, info):
     conversion = self._InputConversion(type_name, info.declared_name)
     if conversion:
       return conversion.input_type
     else:
       # If typedef it's a union return dynamic.
       if self._database.HasTypeDef(type_name):
         return 'dynamic'
       else:
         return self._NarrowInputType(type_name) if type_name else 'dynamic'