Support virtual fields in DDC without requiring the @virtual annotation.

tests/language_strong/field_override5_test.dart

Index: tests/language_strong/field_override5_test.dart
diff --git a/tests/language_strong/field_override5_test.dart b/tests/language_strong/field_override5_test.dart
new file mode 100644
index 0000000000000000000000000000000000000000..f86926c84589bf95bac7574768d474617101760d
--- /dev/null
+++ b/tests/language_strong/field_override5_test.dart
@@ -0,0 +1,512 @@
+// Copyright (c) 2017, 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.
+
+import "package:expect/expect.dart";
+import "package:meta/meta.dart";
+
+class A {
+  get x0_ => 1;
+
+  @virtual
+  var x1 = 1;
+  get x1_ => 1;
+
+  @virtual
+  var x2 = 1;
+  get x2_ => 1;
+
+  get x3 => 1;
+  get x3_ => 1;
+
+  @virtual
+  var x4 = 1;
+  get x4_ => 1;
+
+  @virtual
+  var x5 = 1;
+  get x5_ => 1;
+
+  @virtual
+  var x6 = 1;
+  get x6_ => 1;
+
+  get x7 => 1;
+  get x7_ => 1;
+
+  get x8 => 1;
+  get x8_ => 1;
+
+  get x9 => 1;
+  get x9_ => 1;
+
+  var xA = 1;
+  get xA_ => 1;
+
+  get xB => xA;
+  get xB_ => 1;
+
+  var xC = 1;
+  get xC_ => 1;
+  get xD => xC;
+  get xD_ => 1;
+
+  @virtual
+  var xE = 1;
+  get xE_ => 1;
+  get xF => xE;
+  get xF_ => 1;
+
+  @virtual
+  var xG = 1;
+  get xG_ => 1;
+  get xH => xG;
+  get xH_ => 1;
+
+  get xI => 1;
+  get xI_ => 1;
+  get xJ => xI;
+  get xJ_ => 1;
+
+  get xK => 1;
+  get xK_ => 1;
+  get xL => xK;
+  get xL_ => 1;
+
+  @virtual
+  var xM = 1;
+  static setXM(o) {
+    o.xM = 9;
+  }
+
+  get xM_before => 1;
+  get xM_after => 9;
+
+  @virtual
+  var xN = 1;
+  static setXN(o) {
+    o.xN = 9;
+  }
+
+  get xN_before => 1;
+  get xN_after => 9;
+
+  @virtual
+  var xO = 1;
+  static setXO(o) {
+    o.xO = 9;
+  }
+
+  get xO_before => 1;
+  get xO_after => 9;
+
+  @virtual
+  var xP = 1;
+  static setXP(o) {
+    o.xP = 9;
+  }
+
+  get xP_before => 1;
+  get xP_after => 9;
+
+  @virtual
+  var xQ1 = 11;
+  @virtual
+  var xQ2 = 12;
+  static setXQ1(o) {
+    o.xQ1 = 91;
+  }
+
+  static setXQ2(o) {
+    o.xQ2 = 92;
+  }
+
+  get xQ1_before => 11;
+  get xQ2_before => 12;
+  get xQ1_after => 91;
+  get xQ2_after => 92;
+
+  @virtual
+  var xR1 = 11;
+  @virtual
+  var xR2 = 12;
+  get xR3 => xR1;
+  static setXR1(o) {
+    o.xR1 = 91;
+  }
+
+  static setXR2(o) {
+    o.xR2 = 92;
+  }
+
+  get xR1_before => 11;
+  get xR2_before => 12;
+  get xR3_before => 11;
+  get xR1_after => 91;
+  get xR2_after => 92;
+  get xR3_after => 91;
+}
+
+class B extends A {
+  get x0_ => 2;
+
+  var x1 = 2;
+  get x1_ => 2;
+
+  get x2 => 2;
+  get x2_ => 2;
+
+  var x3 = 2;
+  get x3_ => 2;
+
+  @virtual
+  var x4 = 2;
+  get x4_ => 2;
+
+  get x5 => 2;
+  get x5_ => 2;
+
+  get x6 => 2;
+  get x6_ => 2;
+
+  get x7 => 2;
+  get x7_ => 2;
+
+  get x8 => super.x8;
+  get x8_ => 1;
+
+  get x9 => super.x9 + 1;
+  get x9_ => 2;
+
+  get xA_ => 1;
+  get xB_ => 1;
+
+  get xC_ => 1;
+  get xD => super.xC + 1;
+  get xD_ => 2;
+
+  get xE_ => 1;
+  get xF => super.xE + 1;
+  get xF_ => 2;
+
+  get xG_ => 1;
+  get xH => super.xG + 1;
+  get xH_ => 2;
+
+  get xI_ => 1;
+  get xJ => super.xI + 1;
+  get xJ_ => 2;
+
+  get xK_ => 1;
+  get xL => super.xK + 1;
+  get xL_ => 2;
+
+  set xM(v) {}
+  get xM_before => 1;
+  get xM_after => 1;
+
+  set xN(v) {
+    super.xN = v;
+  }
+
+  get xN_before => 1;
+  get xN_after => 9;
+
+  set xO(v) {
+    super.xO = v;
+  }
+
+  get xO_before => 1;
+  get xO_after => 9;
+
+  set xP(v) {
+    super.xP = v;
+  }
+
+  get xP_before => 1;
+  get xP_after => 9;
+
+  set xQ2(v) {
+    super.xQ1 = v;
+  }
+
+  get xQ1_before => 11;
+  get xQ2_before => 12;
+  get xQ1_after => 92;
+  get xQ2_after => 12;
+
+  set xR2(v) {
+    super.xR1 = v;
+  }
+
+  get xR3 => super.xR1;
+  get xR1_before => 11;
+  get xR2_before => 12;
+  get xR3_before => 11;
+  get xR1_after => 92;
+  get xR2_after => 12;
+  get xR3_after => 92;
+}
+
+class C extends B {
+  get x0_ => 3;
+  get x1_ => 2;
+  get x2_ => 2;
+  get x3_ => 2;
+
+  var x4 = 3;
+  get x4_ => 3;
+
+  var x5 = 3;
+  get x5_ => 3;
+
+  get x6 => 3;
+  get x6_ => 3;
+
+  var x7 = 3;
+  get x7_ => 3;
+
+  get x8_ => 1;
+
+  get x9 => super.x9 + 1;
+  get x9_ => 3;
+
+  get xA_ => 1;
+  get xB_ => 1;
+
+  get xC_ => 1;
+  get xD_ => 2;
+
+  get xE => 3;
+  get xE_ => 3;
+  get xF_ => 2;
+
+  var xG = 3;
+  get xG_ => 3;
+  get xH_ => 2;
+
+  get xI => 3;
+  get xI_ => 3;
+  get xJ_ => 2;
+
+  var xK = 3;
+  get xK_ => 3;
+  get xL_ => 2;
+
+  get xM_before => 1;
+  get xM_after => 1;
+
+  get xN_before => 1;
+  get xN_after => 9;
+
+  set xO(v) {
+    super.xO = v;
+  }
+
+  get xO_before => 1;
+  get xO_after => 9;
+
+  var xP = 3;
+  get xP_before => 3;
+  get xP_after => 9;
+
+  set xQ1(v) {
+    super.xQ1 = v;
+  }
+
+  set xQ2(v) {
+    super.xQ2 = v;
+  }
+
+  get xQ1_before => 11;
+  get xQ2_before => 12;
+  get xQ1_after => 92;
+  get xQ2_after => 12;
+
+  var xR1 = 3;
+  get xR1_before => 3;
+  get xR2_before => 12;
+  get xR3_before => 11;
+  get xR1_after => 91;
+  get xR2_after => 12;
+  get xR3_after => 92;
+}
+
+main() {
+  var a = new A();
+  var b = new B();
+  var c = new C();
+
+  // Need to make sure that at least the getter override works.
+  Expect.equals(1, a.x0_);
+  Expect.equals(2, b.x0_);
+  Expect.equals(3, c.x0_);
+
+  Expect.equals(a.x1_, a.x1);
+  Expect.equals(b.x1_, b.x1);
+  Expect.equals(c.x1_, c.x1);
+
+  Expect.equals(a.x2_, a.x2);
+  Expect.equals(b.x2_, b.x2);
+  Expect.equals(c.x2_, c.x2);
+
+  Expect.equals(a.x3_, a.x3);
+  Expect.equals(b.x3_, b.x3);
+  Expect.equals(c.x3_, c.x3);
+
+  Expect.equals(a.x4_, a.x4);
+  Expect.equals(b.x4_, b.x4);
+  Expect.equals(c.x4_, c.x4);
+
+  Expect.equals(a.x5_, a.x5);
+  Expect.equals(b.x5_, b.x5);
+  Expect.equals(c.x5_, c.x5);
+
+  Expect.equals(a.x6_, a.x6);
+  Expect.equals(b.x6_, b.x6);
+  Expect.equals(c.x6_, c.x6);
+
+  Expect.equals(a.x7_, a.x7);
+  Expect.equals(b.x7_, b.x7);
+  Expect.equals(c.x7_, c.x7);
+
+  Expect.equals(a.x8_, a.x8);
+  Expect.equals(b.x8_, b.x8);
+  Expect.equals(c.x8_, c.x8);
+
+  Expect.equals(a.x9_, a.x9);
+  Expect.equals(b.x9_, b.x9);
+  Expect.equals(c.x9_, c.x9);
+
+  Expect.equals(a.xA_, a.xA);
+  Expect.equals(b.xA_, b.xA);
+  Expect.equals(c.xA_, c.xA);
+
+  Expect.equals(a.xB_, a.xB);
+  Expect.equals(b.xB_, b.xB);
+  Expect.equals(c.xB_, c.xB);
+
+  Expect.equals(a.xC_, a.xC);
+  Expect.equals(b.xC_, b.xC);
+  Expect.equals(c.xC_, c.xC);
+
+  Expect.equals(a.xD_, a.xD);
+  Expect.equals(b.xD_, b.xD);
+  Expect.equals(c.xD_, c.xD);
+
+  Expect.equals(a.xE_, a.xE);
+  Expect.equals(b.xE_, b.xE);
+  Expect.equals(c.xE_, c.xE);
+
+  Expect.equals(a.xF_, a.xF);
+  Expect.equals(b.xF_, b.xF);
+  Expect.equals(c.xF_, c.xF);
+
+  Expect.equals(a.xG_, a.xG);
+  Expect.equals(b.xG_, b.xG);
+  Expect.equals(c.xG_, c.xG);
+
+  Expect.equals(a.xH_, a.xH);
+  Expect.equals(b.xH_, b.xH);
+  Expect.equals(c.xH_, c.xH);
+
+  Expect.equals(a.xI_, a.xI);
+  Expect.equals(b.xI_, b.xI);
+  Expect.equals(c.xI_, c.xI);
+
+  Expect.equals(a.xJ_, a.xJ);
+  Expect.equals(b.xJ_, b.xJ);
+  Expect.equals(c.xJ_, c.xJ);
+
+  Expect.equals(a.xK_, a.xK);
+  Expect.equals(b.xK_, b.xK);
+  Expect.equals(c.xK_, c.xK);
+
+  Expect.equals(a.xL_, a.xL);
+  Expect.equals(b.xL_, b.xL);
+  Expect.equals(c.xL_, c.xL);
+
+  Expect.equals(a.xM_before, a.xM);
+  Expect.equals(b.xM_before, b.xM);
+  Expect.equals(c.xM_before, c.xM);
+  A.setXM(a);
+  A.setXM(b);
+  A.setXM(c);
+  Expect.equals(a.xM_after, a.xM);
+  Expect.equals(b.xM_after, b.xM);
+  Expect.equals(c.xM_after, c.xM);
+
+  Expect.equals(a.xN_before, a.xN);
+  Expect.equals(b.xN_before, b.xN);
+  Expect.equals(c.xN_before, c.xN);
+  A.setXN(a);
+  A.setXN(b);
+  A.setXN(c);
+  Expect.equals(a.xN_after, a.xN);
+  Expect.equals(b.xN_after, b.xN);
+  Expect.equals(c.xN_after, c.xN);
+
+  Expect.equals(a.xO_before, a.xO);
+  Expect.equals(b.xO_before, b.xO);
+  Expect.equals(c.xO_before, c.xO);
+  A.setXO(a);
+  A.setXO(b);
+  A.setXO(c);
+  Expect.equals(a.xO_after, a.xO);
+  Expect.equals(b.xO_after, b.xO);
+  Expect.equals(c.xO_after, c.xO);
+
+  Expect.equals(a.xP_before, a.xP);
+  Expect.equals(b.xP_before, b.xP);
+  Expect.equals(c.xP_before, c.xP);
+  A.setXP(a);
+  A.setXP(b);
+  A.setXP(c);
+  Expect.equals(a.xP_after, a.xP);
+  Expect.equals(b.xP_after, b.xP);
+  Expect.equals(c.xP_after, c.xP);
+
+  Expect.equals(a.xQ1_before, a.xQ1);
+  Expect.equals(b.xQ1_before, b.xQ1);
+  Expect.equals(c.xQ1_before, c.xQ1);
+  Expect.equals(a.xQ2_before, a.xQ2);
+  Expect.equals(b.xQ2_before, b.xQ2);
+  Expect.equals(c.xQ2_before, c.xQ2);
+  A.setXQ1(a);
+  A.setXQ1(b);
+  A.setXQ1(c);
+  A.setXQ2(a);
+  A.setXQ2(b);
+  A.setXQ2(c);
+  Expect.equals(a.xQ1_after, a.xQ1);
+  Expect.equals(b.xQ1_after, b.xQ1);
+  Expect.equals(c.xQ1_after, c.xQ1);
+  Expect.equals(a.xQ2_after, a.xQ2);
+  Expect.equals(b.xQ2_after, b.xQ2);
+  Expect.equals(c.xQ2_after, c.xQ2);
+
+  Expect.equals(a.xR1_before, a.xR1);
+  Expect.equals(b.xR1_before, b.xR1);
+  Expect.equals(c.xR1_before, c.xR1);
+  Expect.equals(a.xR2_before, a.xR2);
+  Expect.equals(b.xR2_before, b.xR2);
+  Expect.equals(c.xR2_before, c.xR2);
+  Expect.equals(a.xR3_before, a.xR3);
+  Expect.equals(b.xR3_before, b.xR3);
+  Expect.equals(c.xR3_before, c.xR3);
+  A.setXR1(a);
+  A.setXR1(b);
+  A.setXR1(c);
+  A.setXR2(a);
+  A.setXR2(b);
+  A.setXR2(c);
+  Expect.equals(a.xR1_after, a.xR1);
+  Expect.equals(b.xR1_after, b.xR1);
+  Expect.equals(c.xR1_after, c.xR1);
+  Expect.equals(a.xR2_after, a.xR2);
+  Expect.equals(b.xR2_after, b.xR2);
+  Expect.equals(c.xR2_after, c.xR2);
+  Expect.equals(a.xR3_after, a.xR3);
+  Expect.equals(b.xR3_after, b.xR3);
+  Expect.equals(c.xR3_after, c.xR3);
+}