Check in codegen test expectations.

Codegen output is checked into repository to make codegen regressions
more visible (especially readability regressions).

BUG=
[email protected]

Review URL: https://codereview.chromium.org/2128353002 .

Author: leafpetersen

pkg/dev_compiler/test/codegen_expected/BenchmarkBase.js

@@ -0,0 +1,96 @@
+dart_library.library('BenchmarkBase', null, /* Imports */[
+  'dart_sdk'
+], function load__BenchmarkBase(exports, dart_sdk) {
+  'use strict';
+  const core = dart_sdk.core;
+  const dart = dart_sdk.dart;
+  const dartx = dart_sdk.dartx;
+  const BenchmarkBase$ = Object.create(null);
+  let VoidTodynamic = () => (VoidTodynamic = dart.constFn(dart.definiteFunctionType(dart.dynamic, [])))();
+  BenchmarkBase$.Expect = class Expect extends core.Object {
+    static equals(expected, actual) {
+      if (!dart.equals(expected, actual)) {
+        dart.throw(dart.str`Values not equal: ${expected} vs ${actual}`);
+      }
+    }
+    static listEquals(expected, actual) {
+      if (expected[dartx.length] != actual[dartx.length]) {
+        dart.throw(dart.str`Lists have different lengths: ${expected[dartx.length]} vs ${actual[dartx.length]}`);
+      }
+      for (let i = 0; i < dart.notNull(actual[dartx.length]); i++) {
+        BenchmarkBase$.Expect.equals(expected[dartx.get](i), actual[dartx.get](i));
+      }
+    }
+    fail(message) {
+      dart.throw(message);
+    }
+  };
+  dart.setSignature(BenchmarkBase$.Expect, {
+    methods: () => ({fail: dart.definiteFunctionType(dart.dynamic, [dart.dynamic])}),
+    statics: () => ({
+      equals: dart.definiteFunctionType(dart.void, [dart.dynamic, dart.dynamic]),
+      listEquals: dart.definiteFunctionType(dart.void, [core.List, core.List])
+    }),
+    names: ['equals', 'listEquals']
+  });
+  BenchmarkBase$.BenchmarkBase = class BenchmarkBase extends core.Object {
+    new(name) {
+      this.name = name;
+    }
+    run() {}
+    warmup() {
+      this.run();
+    }
+    exercise() {
+      for (let i = 0; i < 10; i++) {
+        this.run();
+      }
+    }
+    setup() {}
+    teardown() {}
+    static measureFor(f, timeMinimum) {
+      let time = 0;
+      let iter = 0;
+      let watch = new core.Stopwatch();
+      watch.start();
+      let elapsed = 0;
+      while (dart.notNull(elapsed) < dart.notNull(timeMinimum)) {
+        dart.dcall(f);
+        elapsed = watch.elapsedMilliseconds;
+        iter++;
+      }
+      return 1000.0 * dart.notNull(elapsed) / iter;
+    }
+    measure() {
+      this.setup();
+      BenchmarkBase$.BenchmarkBase.measureFor(dart.fn(() => {
+        this.warmup();
+      }, VoidTodynamic()), 100);
+      let result = BenchmarkBase$.BenchmarkBase.measureFor(dart.fn(() => {
+        this.exercise();
+      }, VoidTodynamic()), 2000);
+      this.teardown();
+      return result;
+    }
+    report() {
+      let score = this.measure();
+      core.print(dart.str`${this.name}(RunTime): ${score} us.`);
+    }
+  };
+  dart.setSignature(BenchmarkBase$.BenchmarkBase, {
+    constructors: () => ({new: dart.definiteFunctionType(BenchmarkBase$.BenchmarkBase, [core.String])}),
+    methods: () => ({
+      run: dart.definiteFunctionType(dart.void, []),
+      warmup: dart.definiteFunctionType(dart.void, []),
+      exercise: dart.definiteFunctionType(dart.void, []),
+      setup: dart.definiteFunctionType(dart.void, []),
+      teardown: dart.definiteFunctionType(dart.void, []),
+      measure: dart.definiteFunctionType(core.double, []),
+      report: dart.definiteFunctionType(dart.void, [])
+    }),
+    statics: () => ({measureFor: dart.definiteFunctionType(core.double, [core.Function, core.int])}),
+    names: ['measureFor']
+  });
+  // Exports:
+  exports.BenchmarkBase = BenchmarkBase$;
+});

pkg/dev_compiler/test/codegen_expected/async_helper.js

@@ -0,0 +1,76 @@
+dart_library.library('async_helper', null, /* Imports */[
+  'dart_sdk'
+], function load__async_helper(exports, dart_sdk) {
+  'use strict';
+  const core = dart_sdk.core;
+  const dart = dart_sdk.dart;
+  const dartx = dart_sdk.dartx;
+  const async_helper = Object.create(null);
+  let VoidTodynamic = () => (VoidTodynamic = dart.constFn(dart.functionType(dart.dynamic, [])))();
+  let StringToException = () => (StringToException = dart.constFn(dart.definiteFunctionType(core.Exception, [core.String])))();
+  let _Action0Tovoid = () => (_Action0Tovoid = dart.constFn(dart.definiteFunctionType(dart.void, [async_helper._Action0])))();
+  let VoidTovoid = () => (VoidTovoid = dart.constFn(dart.definiteFunctionType(dart.void, [])))();
+  let dynamicTovoid = () => (dynamicTovoid = dart.constFn(dart.definiteFunctionType(dart.void, [dart.dynamic])))();
+  let FnTovoid = () => (FnTovoid = dart.constFn(dart.definiteFunctionType(dart.void, [VoidTodynamic()])))();
+  async_helper._initialized = false;
+  async_helper._Action0 = dart.typedef('_Action0', () => dart.functionType(dart.void, []));
+  async_helper._onAsyncEnd = null;
+  async_helper._asyncLevel = 0;
+  async_helper._buildException = function(msg) {
+    return core.Exception.new(dart.str`Fatal: ${msg}. This is most likely a bug in your test.`);
+  };
+  dart.fn(async_helper._buildException, StringToException());
+  async_helper.asyncTestInitialize = function(callback) {
+    async_helper._asyncLevel = 0;
+    async_helper._initialized = false;
+    async_helper._onAsyncEnd = callback;
+  };
+  dart.fn(async_helper.asyncTestInitialize, _Action0Tovoid());
+  dart.copyProperties(async_helper, {
+    get asyncTestStarted() {
+      return async_helper._initialized;
+    }
+  });
+  async_helper.asyncStart = function() {
+    if (dart.test(async_helper._initialized) && async_helper._asyncLevel == 0) {
+      dart.throw(async_helper._buildException('asyncStart() was called even though we are done ' + 'with testing.'));
+    }
+    if (!dart.test(async_helper._initialized)) {
+      if (async_helper._onAsyncEnd == null) {
+        dart.throw(async_helper._buildException('asyncStart() was called before asyncTestInitialize()'));
+      }
+      core.print('unittest-suite-wait-for-done');
+      async_helper._initialized = true;
+    }
+    async_helper._asyncLevel = dart.notNull(async_helper._asyncLevel) + 1;
+  };
+  dart.fn(async_helper.asyncStart, VoidTovoid());
+  async_helper.asyncEnd = function() {
+    if (dart.notNull(async_helper._asyncLevel) <= 0) {
+      if (!dart.test(async_helper._initialized)) {
+        dart.throw(async_helper._buildException('asyncEnd() was called before asyncStart().'));
+      } else {
+        dart.throw(async_helper._buildException('asyncEnd() was called more often than ' + 'asyncStart().'));
+      }
+    }
+    async_helper._asyncLevel = dart.notNull(async_helper._asyncLevel) - 1;
+    if (async_helper._asyncLevel == 0) {
+      let callback = async_helper._onAsyncEnd;
+      async_helper._onAsyncEnd = null;
+      callback();
+      core.print('unittest-suite-success');
+    }
+  };
+  dart.fn(async_helper.asyncEnd, VoidTovoid());
+  async_helper.asyncSuccess = function(_) {
+    return async_helper.asyncEnd();
+  };
+  dart.fn(async_helper.asyncSuccess, dynamicTovoid());
+  async_helper.asyncTest = function(f) {
+    async_helper.asyncStart();
+    dart.dsend(f(), 'then', async_helper.asyncSuccess);
+  };
+  dart.fn(async_helper.asyncTest, FnTovoid());
+  // Exports:
+  exports.async_helper = async_helper;
+});

pkg/dev_compiler/test/codegen_expected/async_helper/async_helper.js

@@ -0,0 +1,76 @@
+dart_library.library('async_helper', null, /* Imports */[
+  'dart_sdk'
+], function load__async_helper(exports, dart_sdk) {
+  'use strict';
+  const core = dart_sdk.core;
+  const dart = dart_sdk.dart;
+  const dartx = dart_sdk.dartx;
+  const async_helper = Object.create(null);
+  let VoidTodynamic = () => (VoidTodynamic = dart.constFn(dart.functionType(dart.dynamic, [])))();
+  let StringToException = () => (StringToException = dart.constFn(dart.definiteFunctionType(core.Exception, [core.String])))();
+  let _Action0Tovoid = () => (_Action0Tovoid = dart.constFn(dart.definiteFunctionType(dart.void, [async_helper._Action0])))();
+  let VoidTovoid = () => (VoidTovoid = dart.constFn(dart.definiteFunctionType(dart.void, [])))();
+  let dynamicTovoid = () => (dynamicTovoid = dart.constFn(dart.definiteFunctionType(dart.void, [dart.dynamic])))();
+  let FnTovoid = () => (FnTovoid = dart.constFn(dart.definiteFunctionType(dart.void, [VoidTodynamic()])))();
+  async_helper._initialized = false;
+  async_helper._Action0 = dart.typedef('_Action0', () => dart.functionType(dart.void, []));
+  async_helper._onAsyncEnd = null;
+  async_helper._asyncLevel = 0;
+  async_helper._buildException = function(msg) {
+    return core.Exception.new(dart.str`Fatal: ${msg}. This is most likely a bug in your test.`);
+  };
+  dart.fn(async_helper._buildException, StringToException());
+  async_helper.asyncTestInitialize = function(callback) {
+    async_helper._asyncLevel = 0;
+    async_helper._initialized = false;
+    async_helper._onAsyncEnd = callback;
+  };
+  dart.fn(async_helper.asyncTestInitialize, _Action0Tovoid());
+  dart.copyProperties(async_helper, {
+    get asyncTestStarted() {
+      return async_helper._initialized;
+    }
+  });
+  async_helper.asyncStart = function() {
+    if (dart.test(async_helper._initialized) && async_helper._asyncLevel == 0) {
+      dart.throw(async_helper._buildException('asyncStart() was called even though we are done ' + 'with testing.'));
+    }
+    if (!dart.test(async_helper._initialized)) {
+      if (async_helper._onAsyncEnd == null) {
+        dart.throw(async_helper._buildException('asyncStart() was called before asyncTestInitialize()'));
+      }
+      core.print('unittest-suite-wait-for-done');
+      async_helper._initialized = true;
+    }
+    async_helper._asyncLevel = dart.notNull(async_helper._asyncLevel) + 1;
+  };
+  dart.fn(async_helper.asyncStart, VoidTovoid());
+  async_helper.asyncEnd = function() {
+    if (dart.notNull(async_helper._asyncLevel) <= 0) {
+      if (!dart.test(async_helper._initialized)) {
+        dart.throw(async_helper._buildException('asyncEnd() was called before asyncStart().'));
+      } else {
+        dart.throw(async_helper._buildException('asyncEnd() was called more often than ' + 'asyncStart().'));
+      }
+    }
+    async_helper._asyncLevel = dart.notNull(async_helper._asyncLevel) - 1;
+    if (async_helper._asyncLevel == 0) {
+      let callback = async_helper._onAsyncEnd;
+      async_helper._onAsyncEnd = null;
+      callback();
+      core.print('unittest-suite-success');
+    }
+  };
+  dart.fn(async_helper.asyncEnd, VoidTovoid());
+  async_helper.asyncSuccess = function(_) {
+    return async_helper.asyncEnd();
+  };
+  dart.fn(async_helper.asyncSuccess, dynamicTovoid());
+  async_helper.asyncTest = function(f) {
+    async_helper.asyncStart();
+    dart.dsend(f(), 'then', async_helper.asyncSuccess);
+  };
+  dart.fn(async_helper.asyncTest, FnTovoid());
+  // Exports:
+  exports.async_helper = async_helper;
+});

pkg/dev_compiler/test/codegen_expected/closure.js

@@ -0,0 +1,103 @@
+export const closure = Object.create(null);
+import { core, js, dart, dartx } from 'dart_sdk';
+let MapOfMap$Map = () => (MapOfMap$Map = dart.constFn(core.Map$(core.Map, core.Map)))();
+let Foo = () => (Foo = dart.constFn(closure.Foo$()))();
+let ListOfTAndTToListOfT = () => (ListOfTAndTToListOfT = dart.constFn(dart.definiteFunctionType(T => [core.List$(T), [core.List$(T), T]])))();
+let dynamicTovoid = () => (dynamicTovoid = dart.constFn(dart.definiteFunctionType(dart.void, [dart.dynamic])))();
+closure.generic_function = function(T) {
+  return (items: core.List<T>, seed: T): core.List<T> => {
+    let strings = items[dartx.map](core.String)(dart.fn((i: T): string => dart.str`${i}`, dart.definiteFunctionType(core.String, [T])))[dartx.toList]();
+    return items;
+  };
+};
+dart.fn(closure.generic_function, ListOfTAndTToListOfT());
+closure.Callback = dart.typedef('Callback', () => dart.functionType(dart.void, [], {i: core.int}));
+closure.Foo$ = dart.generic(T => {
+  let FooOfT = () => (FooOfT = dart.constFn(closure.Foo$(T)))();
+  class Foo<T> extends core.Object {
+    i: number;
+    b: boolean;
+    s: string;
+    v: T;
+    static some_static_constant: string;
+    static some_static_final: string;
+    static some_static_var: string;
+    new(i: number, v: T) {
+      this.i = i;
+      this.v = v;
+      this.b = null;
+      this.s = null;
+    }
+    static build() {
+      return new (FooOfT())(1, null);
+    }
+    untyped_method(a, b) {}
+    pass(t: T) {
+      T._check(t);
+      return t;
+    }
+    typed_method(foo: closure.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 = null, c: number = null) {}
+    static named_params(a, {b = null, c = null}: {b?: any, c?: number} = {}) {}
+    nullary_method() {}
+    function_params(f: (x: any, y?: any) => number, g: (x: any, opts?: {y?: string, z?: any}) => any, cb: closure.Callback) {
+      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>>} = {}) {}
+    get prop() {
+      return null;
+    }
+    set prop(value: string) {}
+    static get staticProp() {
+      return null;
+    }
+    static set staticProp(value: string) {}
+  }
+  dart.addTypeTests(Foo);
+  dart.setSignature(Foo, {
+    constructors: () => ({
+      new: dart.definiteFunctionType(closure.Foo$(T), [core.int, T]),
+      build: dart.definiteFunctionType(closure.Foo$(T), [])
+    }),
+    methods: () => ({
+      untyped_method: dart.definiteFunctionType(dart.dynamic, [dart.dynamic, dart.dynamic]),
+      pass: dart.definiteFunctionType(T, [T]),
+      typed_method: dart.definiteFunctionType(core.String, [closure.Foo, core.List, core.int, core.num, core.double, core.bool, core.String, js.JsArray, js.JsObject, js.JsFunction]),
+      optional_params: dart.definiteFunctionType(dart.dynamic, [dart.dynamic], [dart.dynamic, core.int]),
+      nullary_method: dart.definiteFunctionType(dart.dynamic, []),
+      function_params: dart.definiteFunctionType(dart.dynamic, [dart.functionType(core.int, [dart.dynamic], [dart.dynamic]), dart.functionType(dart.dynamic, [dart.dynamic], {y: core.String, z: dart.dynamic}), closure.Callback]),
+      run: dart.definiteFunctionType(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: MapOfMap$Map()})
+    }),
+    statics: () => ({named_params: dart.definiteFunctionType(dart.dynamic, [dart.dynamic], {b: dart.dynamic, c: core.int})}),
+    names: ['named_params']
+  });
+  return Foo;
+});
+closure.Foo = Foo();
+/** @final {string} */
+closure.Foo.some_static_constant = "abc";
+/** @final {string} */
+closure.Foo.some_static_final = "abc";
+/** @type {string} */
+closure.Foo.some_static_var = "abc";
+closure.Bar = class Bar extends core.Object {};
+closure.Baz = class Baz extends dart.mixin(closure.Foo$(core.int), closure.Bar) {
+  new(i: number) {
+    super.new(i, 123);
+  }
+};
+dart.addSimpleTypeTests(closure.Baz);
+dart.setSignature(closure.Baz, {
+  constructors: () => ({new: dart.definiteFunctionType(closure.Baz, [core.int])})
+});
+closure.main = function(args): void {
+};
+dart.fn(closure.main, dynamicTovoid());
+/** @final {string} */
+closure.some_top_level_constant = "abc";
+/** @final {string} */
+closure.some_top_level_final = "abc";
+/** @type {string} */
+closure.some_top_level_var = "abc";