Support non-const instance field initializers.

tests/language/field_initialization_order_test.dart

+// Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+// Test that field initializers are evaluated in the right order.
+
+int counter = 0;

[kasperl, 2012/08/24 11:50:23]

Counting is fun, but when you're dealing with order it might be better to use a
stringbuffer and add different markers. Maybe something like:

class Mark {
  static StringBuffer buffer;
  Mark(String op) {
    buffer.add("${op}.");
  }
}

String do(callback) {
  Mark.buffer = new StringBuffer();
  callback();
  return Mark.buffer.toString();
}

and then: 

class OneField {
  var a = new Mark("a");
  OneField();
  OneField.init() : a = new Mark("ai");
}

and then the tests:

main() {
  Expect.equals("a.", do(() => new OneField()));
  Expect.equals("a.ai.", do(() => new OneField.init()));
  ...
}

[ngeoffray, 2012/08/24 13:01:41]

Thanks for the suggestion. Done.

+
+class Incr {
+  int value;
+  Incr() {
+    value = counter++;
+  }
+}
+
+class OneField {
+  var a = new Incr();
+
+  OneField(int expectedValue) {
+    Expect.equals(expectedValue, a.value);
+  }
+
+  OneField.init(int expectedValue) : a = new Incr() {
+    Expect.equals(expectedValue, a.value);
+  }
+}
+
+class TwoFields {
+  var b = new Incr();
+  var a = new Incr();
+
+  TwoFields(int expectedValueForA, int expectedValueForB) {
+    Expect.equals(expectedValueForA, a.value);
+    Expect.equals(expectedValueForB, b.value);
+  }
+
+  TwoFields.initA(int expectedValueForA, int expectedValueForB)
+      : a = new Incr() {
+    Expect.equals(expectedValueForA, a.value);
+    Expect.equals(expectedValueForB, b.value);
+  }
+
+  TwoFields.initB(int expectedValueForA, int expectedValueForB)
+      : b = new Incr() {
+    Expect.equals(expectedValueForA, a.value);
+    Expect.equals(expectedValueForB, b.value);
+  }
+
+  TwoFields.initBoth(int expectedValueForA, int expectedValueForB)
+      : a = new Incr(), b = new Incr() {
+    Expect.equals(expectedValueForA, a.value);
+    Expect.equals(expectedValueForB, b.value);
+  }
+}
+
+class InheritOneField extends OneField {
+  var b = new Incr();
+
+  InheritOneField(int expectedValueForA, int expectedValueForB)
+      : super(expectedValueForA) {
+    Expect.equals(expectedValueForB, b.value);
+  }
+
+  InheritOneField.init(int expectedValueForA, int expectedValueForB)
+      : b = new Incr(), super(expectedValueForA) {
+    Expect.equals(expectedValueForB, b.value);
+  }
+
+  InheritOneField.justSuper(int expectedValueForA, int expectedValueForB)
+      : super(expectedValueForA) {
+    Expect.equals(expectedValueForB, b.value);
+  }
+
+  InheritOneField.superWithInit(int expectedValueForA, int expectedValueForB)
+      : super.init(expectedValueForA) {
+    Expect.equals(expectedValueForB, b.value);
+  }
+
+  InheritOneField.initWithSuperInit(int expectedValueForA,
+                                    int expectedValueForB)
+      : b = new Incr(), super.init(expectedValueForA) {
+    Expect.equals(expectedValueForB, b.value);
+  }
+
+  InheritOneField.initWithSuperInit2(int expectedValueForA,
+                                     int expectedValueForB)
+      : super.init(expectedValueForA), b = new Incr() {
+    Expect.equals(expectedValueForB, b.value);
+  }
+}
+
+main() {
+  new OneField(0); counter = 0;
+  new OneField.init(1); counter = 0;
+
+  new TwoFields(1, 0); counter = 0;
+  new TwoFields.initA(2, 0); counter = 0;
+  new TwoFields.initB(1, 2); counter = 0;
+  new TwoFields.initBoth(2, 3); counter = 0;
+
+  new InheritOneField(1, 0); counter = 0;
+  new InheritOneField.init(2, 1); counter = 0;
+  new InheritOneField.justSuper(1, 0); counter = 0;
+  new InheritOneField.superWithInit(2, 0); counter = 0;
+  new InheritOneField.initWithSuperInit(3, 1); counter = 0;
+  new InheritOneField.initWithSuperInit2(2, 3); counter = 0;
+}