Initial support for runtime function types and type checking

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;
 (function (dart) {
   'use strict';
 
   let defineProperty = Object.defineProperty;
   let getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
@@ skipping 108 matching lines @@
       case "boolean":
         return core.bool;
       case "string":
         return core.String;
       case "symbol":
         return Symbol;
     }
     // Undefined is handled above. For historical reasons,
     // typeof null == "object" in JS.
     if (obj === null) return core.Null;
-    return obj.constructor;
+    // TODO(vsm): Should we explicitly check if this is a core.Object?

[Jennifer Messerly, 2015/04/09 18:44:28]

I wondered this too, but since we didn't need it yet, left it out. Not sure if
it's worth adding a TODO? Presumably we can add if we need?

[vsm, 2015/04/09 19:52:25]

Changed the comment a bit.  I think my real question is whether / how we
differentiate between JS objects and Dart ones.

+    var result = obj[dart.runtimeType];

[Jennifer Messerly, 2015/04/09 18:44:28]

what does this do? are you trying to call the Object.runtimeType method or ...?

[vsm, 2015/04/09 19:52:24]

It's only used by tests are the moment.

I was using Object.runtimeType initially, but that triggers errors on actual
runtimeType getters (in the interceptor code) that don't work yet.

More generally, since we're allowing regular JS objects to get here, perhaps we
don't want runtimeType to be a public field?

+    if (result) return result;
+    result = obj.constructor;
+    if (result == Function) {
+      return getFunctionType(obj);
+    }
+    return result;
   }
   dart.getRuntimeType = getRuntimeType;
 
   function instanceOf(obj, type) {
     return isSubtype(getRuntimeType(obj), type);
   }
   dart.is = instanceOf;
 
   /**
    * Computes the canonical type.
@@ skipping 23 matching lines @@
       result = map.get(t2);
       if (result !== void 0) return result;
     } else {
       subtypeMap.set(t1, map = new Map());
     }
     map.set(t2, result = isSubtype_(t1, t2));
     return result;
   }
   dart.isSubtype = isSubtype;
 
-  function isSubtype_(t1, t2) {
+  function _isBottom(type, dynamicIsBottom) {
+    return (type == dart.dynamic && dynamicIsBottom) || type == dart.bottom;
+  }
+
+  function _isTop(type, dynamicIsBottom) {
+    return type == core.Object || (type == dart.dynamic && !dynamicIsBottom);
+  }
+
+  function isSubtype_(t1, t2, opt_dynamicIsBottom) {
+    let dynamicIsBottom =
+      opt_dynamicIsBottom === void 0 ? false : opt_dynamicIsBottom;
+
     t1 = canonicalType(t1);
     t2 = canonicalType(t2);
     if (t1 == t2) return true;
 
     // In Dart, dynamic is effectively both top and bottom.
-    // Here, we treat dynamic as top - the base type of everything.
-    if (t1 == dart.dynamic) return false;
-    if (t2 == dart.dynamic) return true;
+    // Here, we treat dynamic as one or the other depending on context,
+    // but not both.
 
-    if (t2 == core.Object) return true;
-    if (t1 == core.Object) return false;
+    // Trivially true.
+    if (_isTop(t2, dynamicIsBottom) || _isBottom(t1, dynamicIsBottom)) return true;

[Jennifer Messerly, 2015/04/09 18:44:28]

some long lines here

[vsm, 2015/04/09 19:52:24]

Done.  The dart formatter has made me lazy on this front.  :-)

+
+    // Trivially false.
+    if (_isTop(t1, dynamicIsBottom) || _isBottom(t2, dynamicIsBottom)) return false;
 
     // "Traditional" name-based subtype check.
     if (isClassSubType(t1, t2)) {
       return true;
     }
 
     // Function subtyping.
-    // TODO(jmesserly): implement this properly.
-    if (isClassSubType(t1, core.Function) &&
-        isClassSubType(t2, core.Function)) {
-      return true;
+    // TODO(vsm): Handle Objects with call methods.  Those are functions

[Jennifer Messerly, 2015/04/09 18:44:28]

does dart_runtime.dart handle this case?

it wouldn't be hard to get the ".call" method here... but I guess the problem is
it won't have any type info on it yet. =)

you could do arity checks though?

[vsm, 2015/04/09 19:52:25]

Yes.  
I put this off as I don't have a good mental model of how we'll get this to work
(though the subtyping part isn't hard).  Perhaps we can discuss offline.

+    // even if they do not *nominally* subtype core.Function.
+    if (isFunctionType(t1) &&
+        isFunctionType(t2)) {
+      return isFunctionSubType(t1, t2);
     }
     return false;
   }
 
   function safeGetOwnProperty(obj, name) {
     var desc = getOwnPropertyDescriptor(obj, name);
     if (desc) return desc.value;
   }
 
   function isClassSubType(t1, t2) {
     // We support Dart's covariant generics with the caveat that we do not
     // substitute bottom for dynamic in subtyping rules.
     // I.e., given T1, ..., Tn where at least one Ti != dynamic we disallow:
     // - S !<: S<T1, ..., Tn>
     // - S<dynamic, ..., dynamic> !<: S<T1, ..., Tn>
     if (t1 == t2) return true;
 
     if (t1 == core.Object) return false;
 
+    // If t1 is a JS Object, we may not hit core.Object.
+    if (t1 == null) return t2 == core.Object || t2 == dart.dynamic;

[Jennifer Messerly, 2015/04/09 18:44:29]

Hmmm, canonicalType was supposed to be handling this, so we could avoid worrying
about things like that. But maybe it's broken, I see sunflower doesn't load on
master. Doh. Looking at that.

[vsm, 2015/04/09 19:52:25]

Yeah, I was hitting this at runtime.

+
     // Check if t1 and t2 have the same raw type.  If so, check covariance on
     // type parameters.
     let raw1 = safeGetOwnProperty(t1, dart.originalDeclaration);
     let raw2 = safeGetOwnProperty(t2, dart.originalDeclaration);
     if (raw1 != null && raw1 == raw2) {
       let typeArguments1 = safeGetOwnProperty(t1, dart.typeArguments);
       let typeArguments2 = safeGetOwnProperty(t2, dart.typeArguments);
       let length = typeArguments1.length;
       if (typeArguments2.length == 0) {
         // t2 is the raw form of t1
@@ skipping 28 matching lines @@
     if (getInterfaces) {
       for (let i1 of getInterfaces()) {
         // TODO(jmesserly): remove the != null check once we can load core libs.
         if (i1 != null && isClassSubType(i1, t2)) return true;
       }
     }
 
     return false;
   }
 
-  function closureWrap(obj, type) {
-    // TODO(vsm): Remove this once we handle in the checker.
-    return obj;
-  }
-  dart.closureWrap = closureWrap;
-
-
   // TODO(jmesserly): this isn't currently used, but it could be if we want
   // `obj is NonGroundType<T,S>` to be rejected at runtime instead of compile
-  // time. Also TODO: update this to handle functions.
+  // time.
   function isGroundType(type) {
+    // TODO(vsm): Cache this if we start using it at runtime.
+
+    if (type instanceof AbstractFunctionType) {
+      if (!_isTop(type.returnType, false)) return false;
+      for (var i = 0; i < type.args.length; ++i) {
+        if (!_isBottom(type.args[i], true)) return false;
+      }
+      for (var i = 0; i < type.optionals.length; ++i) {
+        if (!_isBottom(type.optionals[i], true)) return false;
+      }
+      var names = Object.getOwnPropertyNames(type.named);
+      for (var i = 0; i < names.length; ++i) {
+        if (!_isBottom(type.named[names[i]], true)) return false;
+      }
+      return true;
+    }
+
     let typeArgs = safeGetOwnProperty(type, dart.typeArguments);
     if (!typeArgs) return true;
     for (let t of typeArgs) {
       if (t != core.Object && t != dart.dynamic) return false;
     }
     return true;
   }
   dart.isGroundType = isGroundType;
 
   function arity(f) {
@@ skipping 10 matching lines @@
   }
   dart.equals = equals;
 
   /** Checks that `x` is not null or undefined. */
   function notNull(x) {
     if (x == null) throw 'expected not-null value';
     return x;
   }
   dart.notNull = notNull;
 
+  function _typeName(type) {
+    // TODO(vsm): Common type object?

[Jennifer Messerly, 2015/04/09 18:44:28]

we could, it's kind of nice to reuse the JS type object when possible though.

thinking longer term, but it'd be nice if Dart objects were envisioned as part
of the ES6+ system and the Dart runtime features too. e.g. our generics and
mixins could be used as just a library by an ES6 user. It's pretty neat that for
a Dart Foo class, you can write `new Foo()` in ES and `foo instanceof Foo` and
it all works, and you can also use our subtype library on JS classes. So it'd be
nice if plain `Foo` was the type object. It's also nice in debugging, with
classes you can type Foo at the console and see the class def

[Jennifer Messerly, 2015/04/09 18:47:24]

having said that, we can certainly have a different internal representation ...
just saying the public APIs should ideally accept JS type objects.

[vsm, 2015/04/09 19:52:25]

That's a good point.

+    if (type instanceof AbstractFunctionType) return type.toString();

[Jennifer Messerly, 2015/04/09 18:44:29]

could you just set a `name` property on this?

[vsm, 2015/04/09 19:52:25]

Done.

+    var name = type.name;
+    if (name) return name;
+    return type.toString();

[Jennifer Messerly, 2015/04/09 18:44:28]

does this happen?

[vsm, 2015/04/09 19:52:25]

Doesn't seem to.  Changed the code to throw.

+  }
+
+  class AbstractFunctionType {
+    constructor() {
+      this._stringValue = null;
+    }
+
+    toString() {
+      if (this._stringValue) return this._stringValue;
+
+      var buffer = '(';
+      for (var i = 0; i < this.args.length; ++i) {
+        if (i > 0) {
+          buffer += ', ';
+        }
+        buffer += _typeName(this.args[i]);
+      }
+      if (this.optionals.length > 0) {
+        if (this.args.length > 0) buffer += ', ';
+        buffer += '[';
+        for (var i = 0; i < this.optionals.length; ++i) {
+          if (i > 0) {
+            buffer += ', ';
+          }
+          buffer += _typeName(this.optionals[i]);
+        }
+        buffer += ']';
+      } else if (this.named.length > 0) {
+        if (this.args.length > 0) buffer += ', ';
+        buffer += '{';
+        let names = Object.getOwnPropertyNames(this.named).sort();
+        for (var i = 0; i < names.length; ++i) {
+          if (i > 0) {
+            buffer += ', ';
+          }
+          buffer += names[i] + ': ' + _typeName(this.named[names[i]]);
+        }
+        buffer += '}';
+      }
+
+      buffer += ') -> ' + _typeName(this.returnType);
+      this._stringValue = buffer;
+      return buffer;
+    }
+  }
+
+  class FunctionType extends AbstractFunctionType {
+    constructor(returnType, args, optionals, named) {
+      super();
+      this.returnType = returnType;
+      this.args = args;
+      this.optionals = optionals;
+      this.named = named;
+    }
+  }
+
+  function functionType(returnType, args, extra) {
+    // TODO(vsm): Cache / memomize?
+    var optionals;
+    var named;
+    if (extra === void 0) {
+      optionals = [];
+      named = {};
+    } else if (extra instanceof Array) {
+      optionals = extra;
+      named = {};
+    } else {
+      optionals = [];
+      named = extra;
+    }
+    return new FunctionType(returnType, args, optionals, named);
+  }
+  dart.functionType = functionType;
+
+  class Typedef extends AbstractFunctionType {
+    constructor(name, closure) {
+      super();
+      this._name = name;
+      this._closure = closure;
+      this._functionType = null;
+    }
+
+    toString() {
+      return this._name;
+    }
+
+    get functionType() {
+      if (!this._functionType) {
+        this._functionType = this._closure();
+      }
+      return this._functionType;
+    }
+
+    get returnType() {
+      return this.functionType.returnType;
+    }
+
+    get args() {
+      return this.functionType.args;
+    }
+
+    get optionals() {
+      return this.functionType.optionals;
+    }
+
+    get named() {
+      return this.functionType.named;
+    }
+  }
+
+  function typedef(name, closure) {
+    return new Typedef(name, closure);
+  }
+  dart.typedef = typedef;
+
+  function isFunctionType(type) {
+    return isClassSubType(type, core.Function) || type instanceof AbstractFunctionType;
+  }
+
+  function getFunctionType(obj) {
+    // TODO(vsm): Encode this properly on the function for Dart-generated code.
+    var args = Array.apply(null, new Array(obj.length)).map(function(){return core.Object});
+    return functionType(dart.bottom, args);
+  }
+
+  function isFunctionSubType(ft1, ft2) {
+    if (ft2 == core.Function) {
+      return true;
+    }
+
+    let ret1 = ft1.returnType;
+    let ret2 = ft2.returnType;
+
+    if (!isSubtype_(ret1, ret2)) {
+      // Covariant return types
+      // Note, void (which can only appear as a return type) is effectively
+      // treated as dynamic.  If the base return type is void, we allow any
+      // subtype return type.
+      // E.g., we allow:
+      //   () -> int <: () -> void
+      if (ret2 != dart.void) {
+        return false;
+      }
+    }
+
+    let args1 = ft1.args;
+    let args2 = ft2.args;
+
+    if (args1.length > args2.length) {
+      return false;
+    }
+
+    for (var i = 0; i < args1.length; ++i) {
+      if (!isSubtype_(args2[i], args1[i], true)) {
+        return false;
+      }
+    }
+
+    let optionals1 = ft1.optionals;
+    let optionals2 = ft2.optionals;
+
+    if (args1.length + optionals1.length < args2.length + optionals2.length) {
+      return false;
+    }
+
+    var j = 0;
+    for (var i = args1.length; i < args2.length; ++i, ++j) {
+      if (!isSubtype_(args2[i], optionals1[j], true)) {
+        return false;
+      }
+    }
+
+    for (var i = 0; i < optionals2.length; ++i, ++j) {
+      if (!isSubtype_(optionals2[i], optionals1[j], true)) {
+        return false;
+      }
+    }
+
+    let named1 = ft1.named;
+    let named2 = ft2.named;
+
+    let names = Object.getOwnPropertyNames(named2);
+    for (var i = 0; i < names.length; ++i) {
+      let name = names[i];
+      let n1 = named1[name]
+      let n2 = named2[name];
+      if (n1 === void 0) {
+        return false;
+      }
+      if (!isSubtype_(n2, n1, true)) {
+        return false;
+      }
+    }
+
+    return true;
+  }
+
   /**
    * Defines a lazy property.
    * After initial get or set, it will replace itself with a value property.
    */
   // TODO(jmesserly): is this the best implementation for JS engines?
   // TODO(jmesserly): reusing descriptor objects has been shown to improve
   // performance in other projects (e.g. webcomponents.js ShadowDOM polyfill).
   function defineLazyProperty(to, name, desc) {
     let init = desc.get;
     let writable = !!desc.set;
@@ skipping 187 matching lines @@
       }
       return value;
     }
     return makeGenericType;
   }
   dart.generic = generic;
 
   // TODO(jmesserly): right now this is a sentinel. It should be a type object
   // of some sort, assuming we keep around `dynamic` at runtime.
   dart.dynamic = { toString() { return 'dynamic'; } };
+  dart.void = { toString() { return 'void'; } };
+  dart.bottom = { toString() { return 'bottom'; } };
+
+  // TODO(vsm): How should we encode the runtime type?
+  dart.runtimeType = Symbol('runtimeType');
 
   dart.JsSymbol = Symbol;
 
   // TODO(jmesserly): hack to bootstrap the SDK
   _js_helper = _js_helper || {};
   _js_helper.checkNum = notNull;
 
 })(dart || (dart = {}));