Type annotations instead of closure comments.

test/codegen/expect/closure.js

Index: test/codegen/expect/closure.js
diff --git a/test/codegen/expect/closure.js b/test/codegen/expect/closure.js
index f8084ab244953329ef1201a7876ba50af255d0b2..cb860ca36305e3d621faa8bf4f03708d0ced4b9c 100644
--- a/test/codegen/expect/closure.js
+++ b/test/codegen/expect/closure.js
@@ -1,148 +1,117 @@
-dart_library.library('closure', null, /* Imports */[
-  'dart/_runtime',
-  'dart/core',
-  'dart/js'
-], /* Lazy imports */[
-], function(exports, dart, core, js) {
-  'use strict';
-  let dartx = dart.dartx;
-  /** @typedef {function({i: (?number|undefined)}=)} */
-  const Callback = dart.typedef('Callback', () => dart.functionType(dart.void, [], {i: core.int}));
-  const Foo$ = dart.generic(function(T) {
-    class Foo extends core.Object {
-      /**
-       * @param {?number} i
-       * @param {?} v
-       */
-      Foo(i, v) {
-        this.i = i;
-        this.v = v;
-        this.b = null;
-        this.s = null;
-      }
-      /** @return {Foo} */
-      static build() {
-        return new (Foo$(T))(1, null);
-      }
-      /**
-       * @param {?} a
-       * @param {?} b
-       */
-      untyped_method(a, b) {}
-      /** @param {?} t */
-      pass(t) {
-        dart.as(t, T);
-        return t;
-      }
-      /**
-       * @param {Foo} foo
-       * @param {core.List} list
-       * @param {?number} i
-       * @param {?number} n
-       * @param {?number} d
-       * @param {?boolean} b
-       * @param {string} s
-       * @param {Array<?>} a
-       * @param {Object<*, *>} o
-       * @param {Function} f
-       * @return {string}
-       */
-      typed_method(foo, list, i, n, d, b, s, a, o, f) {
-        return '';
-      }
-      /**
-       * @param {?} a
-       * @param {?=} b
-       * @param {?=} c
-       */
-      optional_params(a, b, c) {
-        if (b === void 0) b = null;
-        if (c === void 0) c = null;
-      }
-      /**
-       * @param {?} a
-       * @param {{b: (?|undefined), c: (?|undefined)}=} opts
-       */
-      static named_params(a, opts) {
-        let b = opts && 'b' in opts ? opts.b : null;
-        let c = opts && 'c' in opts ? opts.c : null;
-      }
-      nullary_method() {}
-      /**
-       * @param {function(?, ?=):?number} f
-       * @param {function(?, {y: (string|undefined), z: (?|undefined)}=):?} g
-       * @param {Callback} cb
-       */
-      function_params(f, g, cb) {
-        dart.as(f, dart.functionType(core.int, [dart.dynamic], [dart.dynamic]));
-        dart.as(g, dart.functionType(dart.dynamic, [dart.dynamic], {y: core.String, z: dart.dynamic}));
-        cb({i: this.i});
-      }
-      /** @return {string} */
-      get prop() {
-        return null;
-      }
-      /** @param {string} value */
-      set prop(value) {}
-      /** @return {string} */
-      static get staticProp() {
-        return null;
-      }
-      /** @param {string} value */
-      static set staticProp(value) {}
+const exports = {};
+import dart from "./dart/_runtime";
+import core from "./dart/core";
+import js from "./dart/js";
+let dartx = dart.dartx;
+function generic_function<T>(items: core.List<T>, seed: T): core.List<T> {

[Jennifer Messerly, 2016/02/09 16:41:58]

As noted ... this will change, a bit. It'll look a bit more like classes, with
an outer function(T) and an inner function<T>. Dart semantics are likely to
require reification. :|

That said, we could implement it under a reifyGenericFuncTypeArgs flag or
something like that. Defaults to On in normal mode, but closure/typescript mode
could turn off if they want. Probably should have a flag for classes too.

(At least at first, Dart VM will just have parsing support, so it wouldn't be
too inconsistent.)

[ochafik, 2016/02/10 18:12:46]

+1 for reifyGenericFuncTypeArgs
And maybe even a dontReifyGenericClassTypeArgs in the future? :-D

+  let strings = items[dartx.map](dart.fn((i: T): string => `${i}`, core.String, [dart.dynamic]))[dartx.toList]();
+  return items;
+}
+dart.fn(generic_function, () => dart.definiteFunctionType(core.List, [core.List, dart.dynamic]));
+/** @typedef */
+const Callback = dart.typedef('Callback', () => dart.functionType(dart.void, [], {i: core.int}));
+const Foo$ = dart.generic(function(T) {
+  class Foo<T> extends core.Object {

[Jennifer Messerly, 2016/02/09 16:41:58]

super awesome

[ochafik, 2016/02/10 18:12:45]

Hehe, it's only locally awesome, doesn't break out of the generic call yet...

+    i: number;
+    b: boolean;
+    s: string;
+    v: T;
+    static some_static_constant: string;
+    static some_static_final: string;
+    static some_static_var: string;
+    Foo(i: number, v: T) {
+      this.i = i;
+      this.v = v;
+      this.b = null;
+      this.s = null;
     }
-    dart.setSignature(Foo, {
-      constructors: () => ({
-        Foo: [Foo$(T), [core.int, T]],
-        build: [Foo$(T), []]
-      }),
-      methods: () => ({
-        untyped_method: [dart.dynamic, [dart.dynamic, dart.dynamic]],
-        pass: [T, [T]],
-        typed_method: [core.String, [Foo$(), core.List, core.int, core.num, core.double, core.bool, core.String, js.JsArray, js.JsObject, js.JsFunction]],
-        optional_params: [dart.dynamic, [dart.dynamic], [dart.dynamic, dart.dynamic]],
-        nullary_method: [dart.dynamic, []],
-        function_params: [dart.dynamic, [dart.functionType(core.int, [dart.dynamic], [dart.dynamic]), dart.functionType(dart.dynamic, [dart.dynamic], {y: core.String, z: dart.dynamic}), Callback]]
-      }),
-      statics: () => ({named_params: [dart.dynamic, [dart.dynamic], {b: dart.dynamic, c: dart.dynamic}]}),
-      names: ['named_params']
-    });
-    /** @final {string} */
-    Foo.some_static_constant = "abc";
-    /** @final {string} */
-    Foo.some_static_final = "abc";
-    /** @type {string} */
-    Foo.some_static_var = "abc";
-    return Foo;
-  });
-  let Foo = Foo$();
-  class Bar extends core.Object {}
-  const Baz$super = dart.mixin(Foo$(core.int), Bar);
-  class Baz extends Baz$super {
-    /** @param {?number} i */
-    Baz(i) {
-      super.Foo(i, 123);
+    static build() {
+      return new (Foo$(T))(1, null);
+    }
+    untyped_method(a, b) {}
+    pass(t: T) {
+      dart.as(t, T);
+      return t;
+    }
+    typed_method(foo: Foo<any>, list: core.List<any>, i: number, n: number, d: number, b: boolean, s: string, a: any[], o: Object, f: Function) {
+      return '';
+    }
+    optional_params(a, b, c) {
+      if (b === void 0) b = null;
+      if (c === void 0) c = null;
+    }
+    static named_params(a, {b = null, c = null}: {b?: any, c?: any} = {}) {}
+    nullary_method() {}
+    function_params(f: (x: any, y?: any) => number, g: (x: any, opts?: {y?: string, z?: any}) => any, cb: Callback) {
+      dart.as(f, dart.functionType(core.int, [dart.dynamic], [dart.dynamic]));
+      dart.as(g, dart.functionType(dart.dynamic, [dart.dynamic], {y: core.String, z: dart.dynamic}));
+      cb({i: this.i});
+    }
+    run(a: core.List<any>, b: string, c: (d: string) => core.List<any>, e: (f: (g: any) => any) => core.List<number>, {h = null}: {h?: core.Map<core.Map<any, any>, core.Map<any, any>>} = {}) {
+      dart.as(c, dart.functionType(core.List, [core.String]));
+      dart.as(e, dart.functionType(core.List$(core.int), [dart.functionType(dart.dynamic, [dart.dynamic])]));
     }
+    get prop() {
+      return null;
+    }
+    set prop(value: string) {}
+    static get staticProp() {
+      return null;
+    }
+    static set staticProp(value: string) {}
   }
-  dart.setSignature(Baz, {
-    constructors: () => ({Baz: [Baz, [core.int]]})
+  dart.setSignature(Foo, {
+    constructors: () => ({
+      Foo: [Foo$(T), [core.int, T]],
+      build: [Foo$(T), []]
+    }),
+    methods: () => ({
+      untyped_method: [dart.dynamic, [dart.dynamic, dart.dynamic]],
+      pass: [T, [T]],
+      typed_method: [core.String, [Foo$(), core.List, core.int, core.num, core.double, core.bool, core.String, js.JsArray, js.JsObject, js.JsFunction]],
+      optional_params: [dart.dynamic, [dart.dynamic], [dart.dynamic, dart.dynamic]],
+      nullary_method: [dart.dynamic, []],
+      function_params: [dart.dynamic, [dart.functionType(core.int, [dart.dynamic], [dart.dynamic]), dart.functionType(dart.dynamic, [dart.dynamic], {y: core.String, z: dart.dynamic}), Callback]],
+      run: [dart.dynamic, [core.List, core.String, dart.functionType(core.List, [core.String]), dart.functionType(core.List$(core.int), [dart.functionType(dart.dynamic, [dart.dynamic])])], {h: core.Map$(core.Map, core.Map)}]
+    }),
+    statics: () => ({named_params: [dart.dynamic, [dart.dynamic], {b: dart.dynamic, c: dart.dynamic}]}),
+    names: ['named_params']
   });
-  /** @param {?} args */
-  function main(args) {
-  }
-  dart.fn(main, dart.void, [dart.dynamic]);
   /** @final {string} */
-  const some_top_level_constant = "abc";
+  Foo.some_static_constant = "abc";
   /** @final {string} */
-  exports.some_top_level_final = "abc";
+  Foo.some_static_final = "abc";
   /** @type {string} */
-  exports.some_top_level_var = "abc";
-  // Exports:
-  exports.Callback = Callback;
-  exports.Foo$ = Foo$;
-  exports.Foo = Foo;
-  exports.Bar = Bar;
-  exports.Baz = Baz;
-  exports.main = main;
-  exports.some_top_level_constant = some_top_level_constant;
+  Foo.some_static_var = "abc";
+  return Foo;
+});
+let Foo = Foo$();
+class Bar extends core.Object {}
+const Baz$super = dart.mixin(Foo$(core.int), Bar);
+class Baz extends Baz$super {
+  Baz(i: number) {
+    super.Foo(i, 123);
+  }
+}
+dart.setSignature(Baz, {
+  constructors: () => ({Baz: [Baz, [core.int]]})
 });
+function main(args): void {
+}
+dart.fn(main, dart.void, [dart.dynamic]);
+/** @final {string} */
+const some_top_level_constant: string = "abc";
+/** @final {string} */
+exports.some_top_level_final = "abc";
+/** @type {string} */
+exports.some_top_level_var = "abc";
+// Exports:
+exports.generic_function = generic_function;
+exports.Callback = Callback;
+exports.Foo$ = Foo$;
+exports.Foo = Foo;
+exports.Bar = Bar;
+exports.Baz = Baz;
+exports.main = main;
+exports.some_top_level_constant = some_top_level_constant;
+export default exports;