Use short array syntax in method 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, {
-    methods: () => ({run: dart.functionType(dart.void, [])})
+    methods: () => ({run: [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, [])}),
+    methods: () => ({nextWeaker: [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])
+      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"));
   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"));
@@ skipping 28 matching lines @@
       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, [])
+      addConstraint: [dart.void, []],
+      satisfy: [Constraint, [dart.dynamic]],
+      destroyConstraint: [dart.void, []],
+      isInput: [core.bool, []]
     })
   });
   class UnaryConstraint extends Constraint {
     UnaryConstraint(myOutput, strength) {
       this.myOutput = myOutput;
       this.satisfied = false;
       super.Constraint(strength);
       this.addConstraint();
     }
     addToGraph() {
@@ skipping 23 matching lines @@
       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, [])
+      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, {
-    methods: () => ({execute: dart.functionType(dart.void, [])})
+    methods: () => ({execute: [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, [])
+      isInput: [core.bool, []],
+      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 47 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, {
     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, [])
+      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]],
+      removeFromGraph: [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();
@@ skipping 21 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, [])
+      addToGraph: [dart.void, []],
+      removeFromGraph: [dart.void, []],
+      markInputs: [dart.void, [core.int]],
+      execute: [dart.void, []],
+      recalculate: [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, [])})
+    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, {
     methods: () => ({
-      addConstraint: dart.functionType(dart.void, [Constraint]),
-      removeConstraint: dart.functionType(dart.void, [Constraint])
+      addConstraint: [dart.void, [Constraint]],
+      removeConstraint: [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))
         ;
@@ skipping 80 matching lines @@
       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)])
+      incrementalAdd: [dart.void, [Constraint]],
+      incrementalRemove: [dart.void, [Constraint]],
+      newMark: [core.int, []],
+      makePlan: [Plan, [core.List$(Constraint)]],
+      extractPlanFromConstraints: [Plan, [core.List$(Constraint)]],
+      addPropagate: [core.bool, [Constraint, core.int]],
+      removePropagateFrom: [core.List$(Constraint), [Variable]],
+      addConstraintsConsumingTo: [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();
       }
     }
   }
   dart.setSignature(Plan, {
     methods: () => ({
-      addConstraint: dart.functionType(dart.void, [Constraint]),
-      size: dart.functionType(core.int, []),
-      execute: dart.functionType(dart.void, [])
+      addConstraint: [dart.void, [Constraint]],
+      size: [core.int, []],
+      execute: [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)
@@ skipping 78 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);