Added tests to previously broken functionality and added null checks.

tools/dom/scripts/htmldartgenerator.py

Index: tools/dom/scripts/htmldartgenerator.py
diff --git a/tools/dom/scripts/htmldartgenerator.py b/tools/dom/scripts/htmldartgenerator.py
index 0dc105415817ab79c08e15ece11bbb821d4f9215..6635a2a8a39c2f59794bf9abfae6978c412d7bfa 100644
--- a/tools/dom/scripts/htmldartgenerator.py
+++ b/tools/dom/scripts/htmldartgenerator.py
@@ -234,17 +234,32 @@ class HtmlDartGenerator(object):
       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:]])