Initial support for runtime function types and type checking

lib/runtime/dart/_internal.js

Index: lib/runtime/dart/_internal.js
diff --git a/lib/runtime/dart/_internal.js b/lib/runtime/dart/_internal.js
index 5744266645907a7ef4f560614480eaae8855ea17..c124edb1eaa3ec7fe794c9b18f73bb0e975c1e80 100644
--- a/lib/runtime/dart/_internal.js
+++ b/lib/runtime/dart/_internal.js
@@ -348,7 +348,7 @@ var _internal;
   });
   let ListIterator = ListIterator$();
   let _Transformation$ = dart.generic(function(S, T) {
-    class _Transformation extends core.Function {}
+    let _Transformation = dart.typedef('_Transformation', () => dart.functionType(T, [S]));

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

so, the reason I made it a class ... it seemed like function types are basically
a special case:

    typedef R Foo(T t, S s);

is sort-of sugar for:

    class Foo {
      R call(T t, S s);
    }

("sort-of" because nominal vs structural in type checks)

So once we had method type signatures, function types would "fall out" for free,
and we wouldn't need two ways of emitting type signatures: we could just read it
from the "call" method. Granted, we'd still need to mark typedefs, so they are
treated structurally instead of nominally :)

Taking this even further, in hypothetical ES7 we could do signatures like this:

    function printLabel(obj: string) {}

so maybe just polyfill that?

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

I had thought of this, but I found it confusing to conflate the two.  The
semantics are different - not just the nominal vs structural but the difference
in variance.  Type parameters are covariant in generics but not in typedefs.

     return _Transformation;
   });
   let _Transformation = _Transformation$();
@@ -447,7 +447,7 @@ var _internal;
   });
   let MappedListIterable = MappedListIterable$();
   let _ElementPredicate$ = dart.generic(function(E) {
-    class _ElementPredicate extends core.Function {}
+    let _ElementPredicate = dart.typedef('_ElementPredicate', () => dart.functionType(core.bool, [E]));
     return _ElementPredicate;
   });
   let _ElementPredicate = _ElementPredicate$();
@@ -488,7 +488,7 @@ var _internal;
   });
   let WhereIterator = WhereIterator$();
   let _ExpandFunction$ = dart.generic(function(S, T) {
-    class _ExpandFunction extends core.Function {}
+    let _ExpandFunction = dart.typedef('_ExpandFunction', () => dart.functionType(core.Iterable$(T), [S]));
     return _ExpandFunction;
   });
   let _ExpandFunction = _ExpandFunction$();
@@ -500,7 +500,7 @@ var _internal;
         super.IterableBase();
       }
       get [core.$iterator]() {
-        return new (ExpandIterator$(S, T))(this[_iterable][core.$iterator], dart.as(this[_f], dart.throw_("Unimplemented type (S) → Iterable<T>")));
+        return new (ExpandIterator$(S, T))(this[_iterable][core.$iterator], dart.as(this[_f], dart.functionType(core.Iterable$(T), [S])));

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

use functional ordering?

    dart.functionType(S, core.Iterable$(T))

so the type of `TResult foo(TArg0 arg0, TArg1 arg1` would be ]

    dart.functionType(TArg0, TArg1, TResult)

optional and named args are a little wacky, but those could be similar:

    dart.functionType(TArg0, [TArg1, TArg2], TResult)

    dart.functionType(TArg0, {arg1: TArg1, arg2: TArg2}, TResult)

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

In Dart source (e.g., typedefs, function params), the return type is first.  :-)

[Jennifer Messerly, 2015/04/10 00:57:18]

i mean, kind of, but not really. In a function declaration, yes. At use sites?
We don't have an expression form for creating function types. If we did, it
might very well follow Arg -> Return type order. I mean consider C#: Func<S, T>
is a function that accepts an S and returns T. Similar is C#'s equivalent of
`map`: list.select<T,R>(arg) // takes a T, returns an R ... ditto Guava for
Java:
http://docs.guava-libraries.googlecode.com/git/javadoc/com/google/common/base...
... I don't recall that ever coming up as a point of confusion. Especially
nowadays with lambdas: (arg1, arg2) => myResult ... the ordering feels very
natural for programmers.

       }
     }
     return ExpandIterable;
@@ -615,7 +615,7 @@ var _internal;
         super.IterableBase();
       }
       get [core.$iterator]() {
-        return new (TakeWhileIterator$(E))(this[_iterable][core.$iterator], dart.as(this[_f], dart.throw_("Unimplemented type (E) → bool")));
+        return new (TakeWhileIterator$(E))(this[_iterable][core.$iterator], dart.as(this[_f], dart.functionType(core.bool, [E])));
       }
     }
     return TakeWhileIterable;
@@ -726,7 +726,7 @@ var _internal;
         super.IterableBase();
       }
       get [core.$iterator]() {
-        return new (SkipWhileIterator$(E))(this[_iterable][core.$iterator], dart.as(this[_f], dart.throw_("Unimplemented type (E) → bool")));
+        return new (SkipWhileIterator$(E))(this[_iterable][core.$iterator], dart.as(this[_f], dart.functionType(core.bool, [E])));
       }
     }
     return SkipWhileIterable;
@@ -1061,7 +1061,7 @@ var _internal;
         return buffer.toString();
       }
       where(iterable, f) {
-        return new (WhereIterable$(T))(dart.as(iterable, core.Iterable$(T)), dart.as(f, dart.throw_("Unimplemented type (T) → bool")));
+        return new (WhereIterable$(T))(dart.as(iterable, core.Iterable$(T)), dart.as(f, dart.functionType(core.bool, [T])));
       }
       static map(iterable, f) {
         return new MappedIterable(iterable, f);
@@ -1076,13 +1076,13 @@ var _internal;
         return new (SubListIterable$(T))(dart.as(list, core.Iterable$(T)), 0, n);
       }
       takeWhile(iterable, test) {
-        return new (TakeWhileIterable$(T))(dart.as(iterable, core.Iterable$(T)), dart.as(test, dart.throw_("Unimplemented type (T) → bool")));
+        return new (TakeWhileIterable$(T))(dart.as(iterable, core.Iterable$(T)), dart.as(test, dart.functionType(core.bool, [T])));
       }
       skipList(list, n) {
         return new (SubListIterable$(T))(dart.as(list, core.Iterable$(T)), n, null);
       }
       skipWhile(iterable, test) {
-        return new (SkipWhileIterable$(T))(dart.as(iterable, core.Iterable$(T)), dart.as(test, dart.throw_("Unimplemented type (T) → bool")));
+        return new (SkipWhileIterable$(T))(dart.as(iterable, core.Iterable$(T)), dart.as(test, dart.functionType(core.bool, [T])));
       }
       reversedList(list) {
         return new (ReversedListIterable$(T))(dart.as(list, core.Iterable$(T)));