Remove more question marks.

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 217 matching lines @@
       generate_call(stmts_emitter, call_emitter,
           version[0], signature_index, argument_count)
 
     def GenerateChecksAndCall(signature_index, argument_count):
       checks = []
       for i in range(0, argument_count):
         argument = signatures[signature_index][i]
         parameter_name = parameter_names[i]
         test_type = self._DartType(argument.type.id)
         if test_type in ['dynamic', 'Object']:
-          checks.append('?%s' % parameter_name)
+          checks.append('%s != null' % parameter_name)
         elif not can_omit_type_check(test_type, i):
           checks.append('(%s is %s || %s == null)' % (
               parameter_name, test_type, parameter_name))
       # There can be multiple presence checks.  We need them all since a later
       # optional argument could have been passed by name, leaving 'holes'.
-      checks.extend(['!?%s' % name for name in parameter_names[argument_count:]])
+      checks.extend(['%s == null' % name for name in parameter_names[argument_count:]])

[blois, 2013/05/09 22:35:22]

line length

[Anton Muhin, 2013/05/14 14:48:23]

BTW, another potential source of semantic differences.

Regard something like foo(A a) and foo() overloads.  Formerly we could
distinguish one from another, now we will always default to the first one.

 
       GenerateCall(signature_index, argument_count, checks)
 
     # TODO: Optimize the dispatch to avoid repeated checks.
     if len(signatures) > 1:
       index_swaps = {}
       for signature_index, signature in enumerate(signatures):
         for argument_position, argument in enumerate(signature):
           if argument.type.id != 'ArrayBuffer':
             continue
@@ skipping 17 matching lines @@
             GenerateChecksAndCall(signature_index, argument_position)
         GenerateChecksAndCall(signature_index, len(signature))
       body_emitter.Emit(
           '    throw new ArgumentError("Incorrect number or type of arguments");'
           '\n');
     else:
       signature = signatures[0]
       argument_count = len(signature)
       for argument_position, argument in list(enumerate(signature))[::-1]:
         if is_optional(0, argument):
-          check = '?%s' % parameter_names[argument_position]
+          check = '%s != null' % parameter_names[argument_position]
           # argument_count instead of argument_position + 1 is used here to cover one
           # complicated case with the effectively optional argument in the middle.
           # Consider foo(x, optional y, [Default=NullString] optional z)
           # (as of now it's modelled after HTMLMediaElement.webkitAddKey).
           # y is optional in WebCore, while z is not.
           # In this case, if y was actually passed, we'd like to emit foo(x, y, z) invocation,
           # not foo(x, y).
           GenerateCall(0, argument_count, [check])
           argument_count = argument_position
       GenerateCall(0, argument_count, [])
@@ skipping 62 matching lines @@
       constructor_info, factory_name, factory_constructor_name):
     if self.GenerateCustomFactory(constructor_info):
       return
 
     metadata = self._metadata.GetFormattedMetadata(
         self._library_name, self._interface, self._interface.id, '  ')
 
     if not factory_constructor_name:
       factory_constructor_name = '_create'
       factory_parameters = constructor_info.ParametersAsArgumentList()
-      has_factory_provider = True
     else:
       factory_parameters = ', '.join(constructor_info.factory_parameters)
-      has_factory_provider = False
 
     if constructor_info.pure_dart_constructor:
       # TODO(antonm): use common dispatcher generation for this case as well.
       has_optional = any(param_info.is_optional
           for param_info in constructor_info.param_infos)
 
       if not has_optional:
         self._members_emitter.Emit(
             '\n  $(METADATA)'
             'factory $CTOR($PARAMS) => '
             '$FACTORY.$CTOR_FACTORY_NAME($FACTORY_PARAMS);\n',
             CTOR=constructor_info._ConstructorFullName(self._DartType),
             PARAMS=constructor_info.ParametersDeclaration(self._DartType),
             FACTORY=factory_name,
             METADATA=metadata,
             CTOR_FACTORY_NAME=factory_constructor_name,
             FACTORY_PARAMS=factory_parameters)
       else:
-        if has_factory_provider:
-          dispatcher_emitter = self._members_emitter.Emit(
-              '\n  $(METADATA)'
-              'factory $CTOR($PARAMS) {\n'
-              '$!DISPATCHER'
-              '    return $FACTORY._create($FACTORY_PARAMS);\n'
-              '  }\n',
-              CTOR=constructor_info._ConstructorFullName(self._DartType),
-              PARAMS=constructor_info.ParametersDeclaration(self._DartType),
-              FACTORY=factory_name,
-              METADATA=metadata,
-              FACTORY_PARAMS=constructor_info.ParametersAsArgumentList())
+        inits = self._members_emitter.Emit(

[Anton Muhin, 2013/05/14 14:48:23]

please, a separate change or rebase if not too late

+            '\n  $(METADATA)'
+            'factory $CONSTRUCTOR($PARAMS) {\n'
+            '    var e = $FACTORY.$CTOR_FACTORY_NAME($FACTORY_PARAMS);\n'
+            '$!INITS'
+            '    return e;\n'
+            '  }\n',
+            CONSTRUCTOR=constructor_info._ConstructorFullName(self._DartType),
+            METADATA=metadata,
+            FACTORY=factory_name,
+            CTOR_FACTORY_NAME=factory_constructor_name,
+            PARAMS=constructor_info.ParametersDeclaration(self._DartType),
+            FACTORY_PARAMS=factory_parameters)
 
-          for index, param_info in enumerate(constructor_info.param_infos):
-            if param_info.is_optional:
-              dispatcher_emitter.Emit(
-                '    if ($OPT_PARAM_NAME == null) {\n'
-                '      return $FACTORY._create($FACTORY_PARAMS);\n'
-                '    }\n',
-                OPT_PARAM_NAME=param_info.name,
-                FACTORY=factory_name,
-                FACTORY_PARAMS=constructor_info.ParametersAsArgumentList(index))
-        else:
-          inits = self._members_emitter.Emit(
-              '\n  $(METADATA)'
-              'factory $CONSTRUCTOR($PARAMS) {\n'
-              '    var e = $FACTORY.$CTOR_FACTORY_NAME($FACTORY_PARAMS);\n'
-              '$!INITS'
-              '    return e;\n'
-              '  }\n',
-              CONSTRUCTOR=constructor_info._ConstructorFullName(self._DartType),
-              METADATA=metadata,
-              FACTORY=factory_name,
-              CTOR_FACTORY_NAME=factory_constructor_name,
-              PARAMS=constructor_info.ParametersDeclaration(self._DartType),
-              FACTORY_PARAMS=factory_parameters)
-
-          for index, param_info in enumerate(constructor_info.param_infos):
-            if param_info.is_optional:
-              inits.Emit('    if ($E != null) e.$E = $E;\n', E=param_info.name)
+        for index, param_info in enumerate(constructor_info.param_infos):
+          if param_info.is_optional:
+            inits.Emit('    if ($E != null) e.$E = $E;\n', E=param_info.name)
     else:
       def GenerateCall(
           stmts_emitter, call_emitter,
           version, signature_index, argument_count):
         name = emitter.Format('_create_$VERSION', VERSION=version)
         call_emitter.Emit('$FACTORY.$NAME($FACTORY_PARAMS)',
             FACTORY=factory_name,
             NAME=name,
             FACTORY_PARAMS= \
                 constructor_info.ParametersAsArgumentList(argument_count))
@@ skipping 160 matching lines @@
     if interface.parents:
       parent = interface.parents[0]
       if IsPureInterface(parent.type.id):
         walk(interface.parents)
       else:
         walk(interface.parents[1:])
     return result
 
   def _DartType(self, type_name):
     return self._type_registry.DartType(type_name)