Tag closures with their types

test/codegen/expect/DeltaBlue.js

 var DeltaBlue = dart.defineLibrary(DeltaBlue, {});
 var BenchmarkBase = dart.import(BenchmarkBase);
 var core = dart.import(core);
 (function(exports, BenchmarkBase, core) {
   'use strict';
-  // Function main: () → dynamic
   function main() {
     new DeltaBlue().report();
   }
+  dart.fn(main);
   class DeltaBlue extends BenchmarkBase.BenchmarkBase {
     DeltaBlue() {
       super.BenchmarkBase("DeltaBlue");
     }
     run() {
       chainTest(100);
       projectionTest(100);
     }
   }
+  dart.setSignature(DeltaBlue, {
+    methods: () => ({run: dart.functionType(dart.void, [])})
+  });
   class Strength extends core.Object {
     Strength(value, name) {
       this.value = value;
       this.name = name;
     }
     nextWeaker() {
       return dart.const(dart.setType([STRONG_PREFERRED, PREFERRED, STRONG_DEFAULT, NORMAL, WEAK_DEFAULT, WEAKEST], core.List$(Strength)))[core.$get](this.value);
     }
     static stronger(s1, s2) {
       return dart.notNull(s1.value) < dart.notNull(s2.value);
     }
     static weaker(s1, s2) {
       return dart.notNull(s1.value) > dart.notNull(s2.value);
     }
     static weakest(s1, s2) {
       return Strength.weaker(s1, s2) ? s1 : s2;
     }
     static strongest(s1, s2) {
       return Strength.stronger(s1, s2) ? s1 : s2;
     }
   }
+  dart.setSignature(Strength, {
+    methods: () => ({nextWeaker: dart.functionType(Strength, [])}),
+    statics: () => ({
+      stronger: dart.functionType(core.bool, [Strength, Strength]),
+      weaker: dart.functionType(core.bool, [Strength, Strength]),
+      weakest: dart.functionType(Strength, [Strength, Strength]),
+      strongest: dart.functionType(Strength, [Strength, Strength])
+    }),
+    names: ['stronger', 'weaker', 'weakest', 'strongest']
+  });
   let REQUIRED = dart.const(new Strength(0, "required"));
   let STRONG_PREFERRED = dart.const(new Strength(1, "strongPreferred"));
   let PREFERRED = dart.const(new Strength(2, "preferred"));
   let STRONG_DEFAULT = dart.const(new Strength(3, "strongDefault"));
   let NORMAL = dart.const(new Strength(4, "normal"));
   let WEAK_DEFAULT = dart.const(new Strength(5, "weakDefault"));
   let WEAKEST = dart.const(new Strength(6, "weakest"));
   class Constraint extends core.Object {
     Constraint(strength) {
       this.strength = strength;
@@ skipping 23 matching lines @@
     }
     destroyConstraint() {
       if (this.isSatisfied())
         exports.planner.incrementalRemove(this);
       this.removeFromGraph();
     }
     isInput() {
       return false;
     }
   }
+  dart.setSignature(Constraint, {
+    methods: () => ({
+      addConstraint: dart.functionType(dart.void, []),
+      satisfy: dart.functionType(Constraint, [dart.dynamic]),
+      destroyConstraint: dart.functionType(dart.void, []),
+      isInput: dart.functionType(core.bool, [])
+    })
+  });
   class UnaryConstraint extends Constraint {
     UnaryConstraint(myOutput, strength) {
       this.myOutput = myOutput;
       this.satisfied = false;
       super.Constraint(strength);
       this.addConstraint();
     }
     addToGraph() {
       this.myOutput.addConstraint(this);
       this.satisfied = false;
@@ skipping 19 matching lines @@
     }
     inputsKnown(mark) {
       return true;
     }
     removeFromGraph() {
       if (this.myOutput != null)
         this.myOutput.removeConstraint(this);
       this.satisfied = false;
     }
   }
+  dart.setSignature(UnaryConstraint, {
+    methods: () => ({
+      addToGraph: dart.functionType(dart.void, []),
+      chooseMethod: dart.functionType(dart.void, [core.int]),
+      isSatisfied: dart.functionType(core.bool, []),
+      markInputs: dart.functionType(dart.void, [core.int]),
+      output: dart.functionType(Variable, []),
+      recalculate: dart.functionType(dart.void, []),
+      markUnsatisfied: dart.functionType(dart.void, []),
+      inputsKnown: dart.functionType(core.bool, [core.int]),
+      removeFromGraph: dart.functionType(dart.void, [])
+    })
+  });
   class StayConstraint extends UnaryConstraint {
     StayConstraint(v, str) {
       super.UnaryConstraint(v, str);
     }
     execute() {}
   }
+  dart.setSignature(StayConstraint, {
+    methods: () => ({execute: dart.functionType(dart.void, [])})
+  });
   class EditConstraint extends UnaryConstraint {
     EditConstraint(v, str) {
       super.UnaryConstraint(v, str);
     }
     isInput() {
       return true;
     }
     execute() {}
   }
+  dart.setSignature(EditConstraint, {
+    methods: () => ({
+      isInput: dart.functionType(core.bool, []),
+      execute: dart.functionType(dart.void, [])
+    })
+  });
   let NONE = 1;
   let FORWARD = 2;
   let BACKWARD = 0;
   class BinaryConstraint extends Constraint {
     BinaryConstraint(v1, v2, strength) {
       this.v1 = v1;
       this.v2 = v2;
       this.direction = NONE;
       super.Constraint(strength);
       this.addConstraint();
@@ skipping 43 matching lines @@
       return i.mark == mark || dart.notNull(i.stay) || dart.notNull(i.determinedBy == null);
     }
     removeFromGraph() {
       if (this.v1 != null)
         this.v1.removeConstraint(this);
       if (this.v2 != null)
         this.v2.removeConstraint(this);
       this.direction = NONE;
     }
   }
+  dart.setSignature(BinaryConstraint, {
+    methods: () => ({
+      chooseMethod: dart.functionType(dart.void, [core.int]),
+      addToGraph: dart.functionType(dart.void, []),
+      isSatisfied: dart.functionType(core.bool, []),
+      markInputs: dart.functionType(dart.void, [core.int]),
+      input: dart.functionType(Variable, []),
+      output: dart.functionType(Variable, []),
+      recalculate: dart.functionType(dart.void, []),
+      markUnsatisfied: dart.functionType(dart.void, []),
+      inputsKnown: dart.functionType(core.bool, [core.int]),
+      removeFromGraph: dart.functionType(dart.void, [])
+    })
+  });
   class ScaleConstraint extends BinaryConstraint {
     ScaleConstraint(src, scale, offset, dest, strength) {
       this.scale = scale;
       this.offset = offset;
       super.BinaryConstraint(src, dest, strength);
     }
     addToGraph() {
       super.addToGraph();
       this.scale.addConstraint(this);
       this.offset.addConstraint(this);
@@ skipping 17 matching lines @@
       }
     }
     recalculate() {
       let ihn = this.input(), out = this.output();
       out.walkStrength = Strength.weakest(this.strength, ihn.walkStrength);
       out.stay = dart.notNull(ihn.stay) && dart.notNull(this.scale.stay) && dart.notNull(this.offset.stay);
       if (out.stay)
         this.execute();
     }
   }
+  dart.setSignature(ScaleConstraint, {
+    methods: () => ({
+      addToGraph: dart.functionType(dart.void, []),
+      removeFromGraph: dart.functionType(dart.void, []),
+      markInputs: dart.functionType(dart.void, [core.int]),
+      execute: dart.functionType(dart.void, []),
+      recalculate: dart.functionType(dart.void, [])
+    })
+  });
   class EqualityConstraint extends BinaryConstraint {
     EqualityConstraint(v1, v2, strength) {
       super.BinaryConstraint(v1, v2, strength);
     }
     execute() {
       this.output().value = this.input().value;
     }
   }
+  dart.setSignature(EqualityConstraint, {
+    methods: () => ({execute: dart.functionType(dart.void, [])})
+  });
   class Variable extends core.Object {
     Variable(name, value) {
       this.constraints = dart.setType([], core.List$(Constraint));
       this.name = name;
       this.value = value;
       this.determinedBy = null;
       this.mark = 0;
       this.walkStrength = WEAKEST;
       this.stay = true;
     }
     addConstraint(c) {
       this.constraints[core.$add](c);
     }
     removeConstraint(c) {
       this.constraints[core.$remove](c);
       if (dart.equals(this.determinedBy, c))
         this.determinedBy = null;
     }
   }
+  dart.setSignature(Variable, {
+    methods: () => ({
+      addConstraint: dart.functionType(dart.void, [Constraint]),
+      removeConstraint: dart.functionType(dart.void, [Constraint])
+    })
+  });
   class Planner extends core.Object {
     Planner() {
       this.currentMark = 0;
     }
     incrementalAdd(c) {
       let mark = this.newMark();
       for (let overridden = c.satisfy(mark); overridden != null; overridden = overridden.satisfy(mark))
         ;
     }
     incrementalRemove(c) {
@@ skipping 76 matching lines @@
     }
     addConstraintsConsumingTo(v, coll) {
       let determining = v.determinedBy;
       for (let i = 0; dart.notNull(i) < dart.notNull(v.constraints[core.$length]); i = dart.notNull(i) + 1) {
         let c = v.constraints[core.$get](i);
         if (dart.notNull(!dart.equals(c, determining)) && dart.notNull(c.isSatisfied()))
           coll[core.$add](c);
       }
     }
   }
+  dart.setSignature(Planner, {
+    methods: () => ({
+      incrementalAdd: dart.functionType(dart.void, [Constraint]),
+      incrementalRemove: dart.functionType(dart.void, [Constraint]),
+      newMark: dart.functionType(core.int, []),
+      makePlan: dart.functionType(Plan, [core.List$(Constraint)]),
+      extractPlanFromConstraints: dart.functionType(Plan, [core.List$(Constraint)]),
+      addPropagate: dart.functionType(core.bool, [Constraint, core.int]),
+      removePropagateFrom: dart.functionType(core.List$(Constraint), [Variable]),
+      addConstraintsConsumingTo: dart.functionType(dart.void, [Variable, core.List$(Constraint)])
+    })
+  });
   class Plan extends core.Object {
     Plan() {
       this.list = dart.setType([], core.List$(Constraint));
     }
     addConstraint(c) {
       this.list[core.$add](c);
     }
     size() {
       return this.list[core.$length];
     }
     execute() {
       for (let i = 0; dart.notNull(i) < dart.notNull(this.list[core.$length]); i = dart.notNull(i) + 1) {
         this.list[core.$get](i).execute();
       }
     }
   }
-  // Function chainTest: (int) → void
+  dart.setSignature(Plan, {
+    methods: () => ({
+      addConstraint: dart.functionType(dart.void, [Constraint]),
+      size: dart.functionType(core.int, []),
+      execute: dart.functionType(dart.void, [])
+    })
+  });
   function chainTest(n) {
     exports.planner = new Planner();
     let prev = null, first = null, last = null;
     for (let i = 0; dart.notNull(i) <= dart.notNull(n); i = dart.notNull(i) + 1) {
       let v = new Variable("v", 0);
       if (prev != null)
         new EqualityConstraint(prev, v, REQUIRED);
       if (i == 0)
         first = v;
       if (i == n)
         last = v;
       prev = v;
     }
     new StayConstraint(last, STRONG_DEFAULT);
     let edit = new EditConstraint(first, PREFERRED);
     let plan = exports.planner.extractPlanFromConstraints(dart.setType([edit], core.List$(Constraint)));
     for (let i = 0; dart.notNull(i) < 100; i = dart.notNull(i) + 1) {
       first.value = i;
       plan.execute();
       if (last.value != i) {
         core.print("Chain test failed:");
         core.print(`Expected last value to be ${i} but it was ${last.value}.`);
       }
     }
   }
-  // Function projectionTest: (int) → void
+  dart.fn(chainTest, dart.void, [core.int]);
   function projectionTest(n) {
     exports.planner = new Planner();
     let scale = new Variable("scale", 10);
     let offset = new Variable("offset", 1000);
     let src = null, dst = null;
     let dests = dart.setType([], core.List$(Variable));
     for (let i = 0; dart.notNull(i) < dart.notNull(n); i = dart.notNull(i) + 1) {
       src = new Variable("src", i);
       dst = new Variable("dst", i);
       dests[core.$add](dst);
@@ skipping 10 matching lines @@
     for (let i = 0; dart.notNull(i) < dart.notNull(n) - 1; i = dart.notNull(i) + 1) {
       if (dests[core.$get](i).value != dart.notNull(i) * 5 + 1000)
         core.print("Projection 3 failed");
     }
     change(offset, 2000);
     for (let i = 0; dart.notNull(i) < dart.notNull(n) - 1; i = dart.notNull(i) + 1) {
       if (dests[core.$get](i).value != dart.notNull(i) * 5 + 2000)
         core.print("Projection 4 failed");
     }
   }
-  // Function change: (Variable, int) → void
+  dart.fn(projectionTest, dart.void, [core.int]);
   function change(v, newValue) {
     let edit = new EditConstraint(v, PREFERRED);
     let plan = exports.planner.extractPlanFromConstraints(dart.setType([edit], core.List$(EditConstraint)));
     for (let i = 0; dart.notNull(i) < 10; i = dart.notNull(i) + 1) {
       v.value = newValue;
       plan.execute();
     }
     edit.destroyConstraint();
   }
+  dart.fn(change, dart.void, [Variable, core.int]);
   exports.planner = null;
   // Exports:
   exports.main = main;
   exports.DeltaBlue = DeltaBlue;
   exports.Strength = Strength;
   exports.REQUIRED = REQUIRED;
   exports.STRONG_PREFERRED = STRONG_PREFERRED;
   exports.PREFERRED = PREFERRED;
   exports.STRONG_DEFAULT = STRONG_DEFAULT;
   exports.NORMAL = NORMAL;
   exports.WEAK_DEFAULT = WEAK_DEFAULT;
   exports.WEAKEST = WEAKEST;
   exports.Constraint = Constraint;
   exports.UnaryConstraint = UnaryConstraint;
   exports.StayConstraint = StayConstraint;
   exports.EditConstraint = EditConstraint;
   exports.NONE = NONE;
   exports.FORWARD = FORWARD;
   exports.BACKWARD = BACKWARD;
   exports.BinaryConstraint = BinaryConstraint;
   exports.ScaleConstraint = ScaleConstraint;
   exports.EqualityConstraint = EqualityConstraint;
   exports.Variable = Variable;
   exports.Planner = Planner;
   exports.Plan = Plan;
   exports.chainTest = chainTest;
   exports.projectionTest = projectionTest;
   exports.change = change;
 })(DeltaBlue, BenchmarkBase, core);