Improve tracking of the type of fields after object construction

lib/compiler/implementation/ssa/optimize.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.
 
 interface OptimizationPhase {
   String get name();
   void visitGraph(HGraph graph);
 }
 
 class SsaOptimizerTask extends CompilerTask {
@@ skipping 1170 matching lines @@
   HGraph graph;
   Compiler get compiler() => backend.compiler;
 
   SsaProcessRecompileCandidates(this.backend, this.work);
 
   void visitGraph(HGraph visitee) {
     graph = visitee;
     visitDominatorTree(visitee);
   }
 
+  void visitFieldGet(HFieldGet node) {
+    if (!node.element.enclosingElement.isClass()) return;
+    Element field = node.element;
+    HType type = backend.optimisticFieldTypeAfterConstruction(field);
+    switch (compiler.phase) {
+      case Compiler.PHASE_COMPILING:
+        if (!type.isConflicting()) {
+          compiler.enqueuer.codegen.registerRecompilationCandidate(
+              work.element);
+        }
+        break;
+      case Compiler.PHASE_RECOMPILING:
+        if (!type.isConflicting() && !type.isUnknown()) {
+          // Check if optimistic type is based on a setter in the constructor
+          // body.
+          if (backend.hasConstructorBodyFieldSetter(field)) {
+            // There is at least one field setter from the constructor.
+            // TODO(sgjesse): Collect the type for all the field setters so that
+            // this could be a guarenteed type if all field setters have the
+            // same type and there are no invoked setters.
+            node.propagatedType = type;
+          } else {
+            // Optimistic type is based in field initializer list.
+            if (!compiler.codegenWorld.hasFieldSetter(field, compiler) &&
+                !compiler.codegenWorld.hasInvokedSetter(field, compiler)) {

[floitsch, 2012/06/22 08:18:12]

what about implicit null-initializations?

[Søren Gjesse, 2012/06/22 09:22:36]

All the implicit null initialized fields will be in the collected information
and indicate a null value. As fas as I can see this just works, e.g.


class A {
  var _x;
  var _y;

  A() : _x = 2;
  A.b();

  get x() => _x;
  get y() => _y;
}

main () {
  var a = new A();
  var ab = new A.b();
  print(a.x);
  print(a.y);
  print(ab.x);
  print(ab.y);
}

here _x will have guaranteedType "integer or null" and _y guaranteedType "null"

+              node.guaranteedType = type;
+            } else {
+              node.propagatedType = type;
+            }
+          }
+        }
+        break;
+    }
+  }
+
   HInstruction visitEquals(HEquals node) {
     // Try to optimize the case where a field which is known to always be an
     // integer is compared with a constant integer literal.
     if (node.left is HFieldGet &&
         node.right is HConstant &&
         node.right.isInteger()) {
       HFieldGet left = node.left;
       HConstant right = node.right;
       if (left.element != null && left.element.enclosingElement.isClass()) {
         switch (compiler.phase) {
@@ skipping 24 matching lines @@
               }
             }
             break;
           default:
             assert(false);
             break;
         }
       }
     }
   }
+
 }