Allow null args to dynamic invocations

lib/runtime/dart_runtime.js

 // Copyright (c) 2015, 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.
 
 var dart, _js_helper, _js_primitives;
 (function (dart) {
   'use strict';
 
   // TODO(vsm): This is referenced (as init.globalState) from
   // isolate_helper.dart.  Where should it go?
@@ skipping 222 matching lines @@
     }
     return result;
   }
   dart.realRuntimeType = realRuntimeType;
 
   function instanceOf(obj, type) {
     return isSubtype(realRuntimeType(obj), type);
   }
   dart.is = instanceOf;
 
+  function instanceOfOrNull(obj, type) {
+    return (obj == null) || instanceOf(obj, type);
+  }
+
   /**
    * Computes the canonical type.
    * This maps JS types onto their corresponding Dart Type.
    */
   // TODO(jmesserly): lots more needs to be done here.
   function canonicalType(t) {
     if (t === Object) return core.Object;
     if (t === Function) return core.Function;
     if (t === Array) return core.List;
 
@@ skipping 205 matching lines @@
     constructor() {
       this._stringValue = null;
     }
 
     /// Check that a function of this type can be applied to 
     /// actuals.
     checkApply(actuals) {
       if (actuals.length < this.args.length) return false;
       var index = 0;
       for(let i = 0; i < this.args.length; ++i) {
-        let t = realRuntimeType(actuals[i]);
-        if (!isSubtype(t, this.args[i])) return false;
+        if (!instanceOfOrNull(actuals[i], this.args[i])) return false;
         ++index;
       }
       if (actuals.length == this.args.length) return true;
       let extras = actuals.length - this.args.length;
       if (this.optionals.length > 0) {
         if (extras > this.optionals.length) return false;
-        for(let i = 0; i < extras; ++i) {
-          let t = realRuntimeType(actuals[index + i]);
-          if (!isSubtype(t, this.optionals[i])) return false;
+        for(let i = 0, j=index; i < extras; ++i, ++j) {
+          if (!instanceOfOrNull(actuals[j], this.optionals[i])) return false;
         }
         return true;
       }
       // TODO(leafp): We can't tell when someone might be calling
       // something expecting an optional argument with named arguments
 
       if (extras != 1) return false;
       // An empty named list means no named arguments
       if (getOwnPropertyNames(this.named).length == 0) return false;
       let opts = actuals[index];
       let names = getOwnPropertyNames(opts);
       // This is something other than a map
       if (names.length == 0) return false;
       for (name of names) {
         if (!(Object.prototype.hasOwnProperty.call(this.named, name))) {
           return false;
         }
-        let t = realRuntimeType(opts[name]);
-        if (!isSubtype(t, this.named[name])) return false;
+        if (!instanceOfOrNull(opts[name], this.named[name])) return false;
       }
       return true;
     }
 
     get name() {
       if (this._stringValue) return this._stringValue;
 
       var buffer = '(';
       for (let i = 0; i < this.args.length; ++i) {
         if (i > 0) {
@@ skipping 776 matching lines @@
   Number.prototype['>'] = function(arg) { return this.valueOf() > arg; };
   Number.prototype['+'] = function(arg) { return this.valueOf() + arg; };
 
   // TODO(vsm): DOM facades?
   // See: https://github.com/dart-lang/dev_compiler/issues/173
   NodeList.prototype.get = function(i) { return this[i]; };
   NamedNodeMap.prototype.get = function(i) { return this[i]; };
   DOMTokenList.prototype.get = function(i) { return this[i]; };
 
 })(dart || (dart = {}));