Added tests to previously broken functionality and added null checks.

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 216 matching lines @@
 
       if is_void:
         call_emitter = call_emitter.Emit('$(INDENT)$!CALL;\n$(INDENT)return;\n')
       else:
         call_emitter = call_emitter.Emit('$(INDENT)return $!CALL;\n')
 
       version[0] += 1
       generate_call(stmts_emitter, call_emitter,
           version[0], signature_index, argument_count)
 
+    def IsDartTypeNullable(type_signature):

[Anton Muhin, 2013/05/23 15:06:25]

Andrei, thanks a lot, now I understand what is the problem.

However, my feeling is it should be addressed somewhat differently.

First of all, I'd kindly ask you to use ?-operator for presence checks:
nullability is rather tricky thing and should be addressed for all ?-operators
in one go and in completely separate CL.

Secondly, if my understanding is correct, all you want is to insert presence
check if argument is optional in Dart declaration, but required by the given
signature, correct?

Example:

foo(var x)
foo(var x, var y, var z)

We'd like to have something like:

if (?x && !?y && !?z) { ... }
if (?x && ?y && ?z) { ... }

as Dart signature would be foo(var x, [var y, var z]).

I'd suggest to implement this logic directly by passing an number of required
arguments in Dart, see something like https://codereview.chromium.org/15885002/
(better approach would be to pass operation info instead)

What do you all think about it?

+      return type_signature not in ['int', 'double', 'num', 'bool']
+
     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)
+        nullable = argument.type.nullable
+
         if test_type in ['dynamic', 'Object']:
           checks.append('?%s' % parameter_name)
         elif not can_omit_type_check(test_type, i):
+          nullable = True
           checks.append('(%s is %s || %s == null)' % (
               parameter_name, test_type, parameter_name))
+
+        if not nullable and not IsDartTypeNullable(test_type):
+          for signature in signatures:
+            if (len(signature) <= i or signature[i].id not in
+                parameter_name.split('_OR_')):
+
+              checks.append('%s != null' % parameter_name)
+              break
+
       # 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:]])
 
       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):
@@ skipping 322 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)