Support allocation sinking for compound objects.

tests/language/vm/allocation_sinking_vm_test.dart

 // Copyright (c) 2013, 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 allocation sinking optimization.
 // VMOptions=--optimization-counter-threshold=10 --no-use-osr
 
 import 'dart:typed_data';
 import 'package:expect/expect.dart';
 
 class Point {
@@ skipping 145 matching lines @@
   var t2 = inner();
   return a.x + t1 + t2;
 }
 
 testVMField() {
   Expect.equals(84, test_vm_field());
   for (var i = 0; i < 100; i++) test_vm_field();
   Expect.equals(84, test_vm_field());
 }
 
+class CompoundA {
+  var b;
+  CompoundA(this.b);
+}
+
+class CompoundB {
+  var c;
+  CompoundB(this.c);
+}
+
+class CompoundC {
+  var d;
+  var root;
+  CompoundC(this.d);
+}
+
+class NoopSink {
+  const NoopSink();
+  call(val) { }
+}
+
+testCompound1() {
+  f(d, [sink = const NoopSink()]) {
+    var c = new CompoundC(d);
+    var a = new CompoundA(new CompoundB(c));
+    sink(a);
+    return c.d;
+  }
+
+  Expect.equals(0.1, f(0.1));
+  for (var i = 0; i < 100; i++) f(0.1);
+  Expect.equals(0.1, f(0.1));
+  Expect.equals(0.1, f(0.1, (val) {
+    Expect.isTrue(val is CompoundA);
+    Expect.isTrue(val.b is CompoundB);
+    Expect.isTrue(val.b.c is CompoundC);
+    Expect.isNull(val.b.c.root);
+    Expect.equals(0.1, val.b.c.d);
+  }));
+}
+
+
+testCompound2() {
+  f(d, [sink = const NoopSink()]) {
+    var c = new CompoundC(d);
+    var a = new CompoundA(new CompoundB(c));
+    c.root = a;
+    sink(a);
+    return c.d;
+  }
+
+  Expect.equals(0.1, f(0.1));
+  for (var i = 0; i < 100; i++) f(0.1);
+  Expect.equals(0.1, f(0.1));
+  Expect.equals(0.1, f(0.1, (val) {
+    Expect.isTrue(val is CompoundA);
+    Expect.isTrue(val.b is CompoundB);
+    Expect.isTrue(val.b.c is CompoundC);
+    Expect.equals(val, val.b.c.root);
+    Expect.equals(0.1, val.b.c.d);
+  }));
+}
+
+
+testCompound3() {
+  f(d, [sink = const NoopSink()]) {
+    var c = new CompoundC(d);
+    c.root = c;
+    sink(c);
+    return c.d;
+  }
+
+  Expect.equals(0.1, f(0.1));
+  for (var i = 0; i < 100; i++) f(0.1);
+  Expect.equals(0.1, f(0.1));
+  Expect.equals(0.1, f(0.1, (val) {
+    Expect.isTrue(val is CompoundC);
+    Expect.equals(val, val.root);
+    Expect.equals(0.1, val.d);
+  }));
+}
+
+
+testCompound4() {
+  f(d, [sink = const NoopSink()]) {
+    var c = new CompoundC(d);
+    c.root = c;
+    for (var i = 0; i < 10; i++) {
+      c.d += 1.0;
+    }
+    sink(c);
+    return c.d - 1.0 * 10;
+  }
+
+  Expect.equals(1.0, f(1.0));
+  for (var i = 0; i < 100; i++) f(1.0);
+  Expect.equals(1.0, f(1.0));
+  Expect.equals(1.0, f(1.0, (val) {
+    Expect.isTrue(val is CompoundC);
+    Expect.equals(val, val.root);
+    Expect.equals(11.0, val.d);
+  }));
+}
+
+
 main() {
   var c = new C(new Point(0.1, 0.2));
 
   // Compute initial values.
   final x0 = test1(c, 11.11, 22.22);
   var fc = new Cx4(new Pointx4(new Float32x4(1.0, 1.0, 1.0, 1.0),
                                new Float32x4(1.0, 1.0, 1.0, 1.0)));
   final fx0 = test1x4(fc, new Float32x4(1.0, 1.0, 1.0, 1.0),
                           new Float32x4(1.0, 1.0, 1.0, 1.0),
                           new Float32x4(1.0, 1.0, 1.0, 1.0),
@@ skipping 37 matching lines @@
 
   // Test that identity of materialized objects is preserved correctly and
   // no copies are materialized.
   final z1 = testIdentity(c.p);
   final z2 = testIdentity(new F(c.p));
   Expect.equals(z0, z1);
   Expect.equals(z0, z2);
 
   testFinalField();
   testVMField();
+  testCompound1();
+  testCompound2();
+  testCompound3();
+  testCompound4();
 }