Add constructors to signatures

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() {
     new DeltaBlue().report();
   }
   dart.fn(main);
   class DeltaBlue extends BenchmarkBase.BenchmarkBase {
     DeltaBlue() {
       super.BenchmarkBase("DeltaBlue");
     }
     run() {
       chainTest(100);
       projectionTest(100);
     }
   }
+  dart.setSignature(DeltaBlue, {
+    constructors: () => ({DeltaBlue: [DeltaBlue, []]})
+  });
   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, {
+    constructors: () => ({Strength: [Strength, [core.int, core.String]]}),
     methods: () => ({nextWeaker: [Strength, []]}),
     statics: () => ({
       stronger: [core.bool, [Strength, Strength]],
       weaker: [core.bool, [Strength, Strength]],
       weakest: [Strength, [Strength, Strength]],
       strongest: [Strength, [Strength, Strength]]
     }),
     names: ['stronger', 'weaker', 'weakest', 'strongest']
   });
   let REQUIRED = dart.const(new Strength(0, "required"));
@@ skipping 33 matching lines @@
     destroyConstraint() {
       if (this.isSatisfied())
         exports.planner.incrementalRemove(this);
       this.removeFromGraph();
     }
     isInput() {
       return false;
     }
   }
   dart.setSignature(Constraint, {
+    constructors: () => ({Constraint: [Constraint, [Strength]]}),
     methods: () => ({
       addConstraint: [dart.void, []],
       satisfy: [Constraint, [core.Object]],
       destroyConstraint: [dart.void, []],
       isInput: [core.bool, []]
     })
   });
   class UnaryConstraint extends Constraint {
     UnaryConstraint(myOutput, strength) {
       this.myOutput = myOutput;
@@ skipping 27 matching lines @@
     inputsKnown(mark) {
       return true;
     }
     removeFromGraph() {
       if (this.myOutput != null)
         this.myOutput.removeConstraint(this);
       this.satisfied = false;
     }
   }
   dart.setSignature(UnaryConstraint, {
+    constructors: () => ({UnaryConstraint: [UnaryConstraint, [Variable, Strength]]}),
     methods: () => ({
       addToGraph: [dart.void, []],
       chooseMethod: [dart.void, [core.int]],
       isSatisfied: [core.bool, []],
       markInputs: [dart.void, [core.int]],
       output: [Variable, []],
       recalculate: [dart.void, []],
       markUnsatisfied: [dart.void, []],
       inputsKnown: [core.bool, [core.int]],
       removeFromGraph: [dart.void, []]
     })
   });
   class StayConstraint extends UnaryConstraint {
     StayConstraint(v, str) {
       super.UnaryConstraint(v, str);
     }
     execute() {}
   }
   dart.setSignature(StayConstraint, {
+    constructors: () => ({StayConstraint: [StayConstraint, [Variable, Strength]]}),
     methods: () => ({execute: [dart.void, []]})
   });
   class EditConstraint extends UnaryConstraint {
     EditConstraint(v, str) {
       super.UnaryConstraint(v, str);
     }
     isInput() {
       return true;
     }
     execute() {}
   }
   dart.setSignature(EditConstraint, {
+    constructors: () => ({EditConstraint: [EditConstraint, [Variable, Strength]]}),
     methods: () => ({execute: [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;
@@ skipping 46 matching lines @@
     }
     removeFromGraph() {
       if (this.v1 != null)
         this.v1.removeConstraint(this);
       if (this.v2 != null)
         this.v2.removeConstraint(this);
       this.direction = NONE;
     }
   }
   dart.setSignature(BinaryConstraint, {
+    constructors: () => ({BinaryConstraint: [BinaryConstraint, [Variable, Variable, Strength]]}),
     methods: () => ({
       chooseMethod: [dart.void, [core.int]],
       addToGraph: [dart.void, []],
       isSatisfied: [core.bool, []],
       markInputs: [dart.void, [core.int]],
       input: [Variable, []],
       output: [Variable, []],
       recalculate: [dart.void, []],
       markUnsatisfied: [dart.void, []],
       inputsKnown: [core.bool, [core.int]],
@@ skipping 31 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, {
+    constructors: () => ({ScaleConstraint: [ScaleConstraint, [Variable, Variable, Variable, Variable, Strength]]}),
     methods: () => ({execute: [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, {
+    constructors: () => ({EqualityConstraint: [EqualityConstraint, [Variable, Variable, Strength]]}),
     methods: () => ({execute: [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, {
+    constructors: () => ({Variable: [Variable, [core.String, core.int]]}),
     methods: () => ({
       addConstraint: [dart.void, [Constraint]],
       removeConstraint: [dart.void, [Constraint]]
     })
   });
   class Planner extends core.Object {
     Planner() {
       this.currentMark = 0;
     }
     incrementalAdd(c) {
@@ skipping 212 matching lines @@
   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);