Simplify type handling for recompilation of field gets.

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 1259 matching lines @@
   void visitGraph(HGraph visitee) {
     graph = visitee;
     if (compiler.phase == Compiler.PHASE_RECOMPILING) {
       visitDominatorTree(visitee);
     }
   }
 
   void handleFieldGet(HFieldGet field, HType type) {
     assert(compiler.phase == Compiler.PHASE_RECOMPILING);
     if (!type.isConflicting()) {
+      // If there are no invoked setters with this name, the union of
+      // the types of the initializers and the setters is guaranteed
+      // otherwise it is only speculative.
       Element element = field.element;
-      // Check if optimistic type is based on a setter in the
-      // constructor body.
-      if (backend.hasConstructorBodyFieldSetter(element)) {
-        // If there are no other field setters then the one in
-        // the constructor body, the type is guaranteed for this
-        // field after construction.
-        assert(!element.isGenerativeConstructorBody());
-        if (!compiler.codegenWorld.hasInvokedSetter(element, compiler)) {
-          field.guaranteedType =
-              type.union(backend.fieldSettersTypeSoFar(element));
-        } else {
-          field.propagatedType =
-              type.union(backend.fieldSettersTypeSoFar(element));
-        }
+      assert(!element.isGenerativeConstructorBody());
+      if (!compiler.codegenWorld.hasInvokedSetter(element, compiler)) {
+        field.guaranteedType =
+            type.union(backend.fieldSettersTypeSoFar(element));
       } else {
-        // If there are no setters the initializer list type is
-        // guaranteed to remain constant.
-        //
-        // TODO(ager): Why is this treated differently from the
-        // case above? It seems to me that we could/should use
-        // the union of the types for the field setters and the
-        // initializer list here? It would give the same when
-        // there are none and potentially better information for
-        // more cases.
-        if (!compiler.codegenWorld.hasFieldSetter(element, compiler) &&
-            !compiler.codegenWorld.hasInvokedSetter(element, compiler)) {
-          field.guaranteedType = type;
-        } else {
-          field.propagatedType = type;
-        }
+        field.propagatedType =
+            type.union(backend.fieldSettersTypeSoFar(element));
       }
     }
   }
 
   void handleFieldNumberOperation(HFieldGet field, HType type) {
     assert(compiler.phase == Compiler.PHASE_RECOMPILING);
     if (compiler.codegenWorld.hasInvokedSetter(field.element, compiler)) {
       // If there are invoked setters we don't know for sure
       // that the field will hold a value of the calculated
       // type, but the fact that the class itself sticks to
       // this type for the field is still a strong signal
       // indicating the expected type of the field.
       field.propagatedType = type;
     } else {
       // If there are no invoked setters we know the type of
       // this field for sure.
       field.guaranteedType = type;
     }
   }
 }