Collect the actual types for all field setters.

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 @@
           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;
+            if (!compiler.codegenWorld.hasInvokedSetter(field, compiler)) {

[Mads Ager (google), 2012/07/05 13:55:19]

Should this be the resolverWorld? Are you sure that you have seen all setter
invocations at this point?

[Mads Ager (google), 2012/07/05 13:56:53]

Ignore me, this is during recompilation so this is correct. :)

+              node.guaranteedType =
+                  type.union(backend.fieldSettersTypeSoFar(node.element));
+            } else {
+              node.propagatedType =
+                  type.union(backend.fieldSettersTypeSoFar(node.element));
+            }
           } else {
-            // Optimistic type is based in field initializer list.
+            // Optimistic type is based on field initializer list.
             if (!compiler.codegenWorld.hasFieldSetter(field, compiler) &&
                 !compiler.codegenWorld.hasInvokedSetter(field, compiler)) {
               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) {
           case Compiler.PHASE_COMPILING:
-            if (backend.onlyFieldIntegerSettersSoFar(left.element) &&
+            if ((backend.fieldSettersTypeSoFar(left.element).isUnknown() ||

[Mads Ager (google), 2012/07/05 13:42:53]

We should probably generalize these things as well. For instance it might make
sense to optimize for numbers as well as only integers?

We can play with that in a separate change.

[Søren Gjesse, 2012/07/06 04:10:32]

Will do.

+                 backend.fieldSettersTypeSoFar(left.element).isInteger()) &&
                 backend.couldHaveFieldSingleTypeInitializers(
                     left.element, HType.INTEGER)) {
               compiler.enqueuer.codegen.registerRecompilationCandidate(
                   work.element);
             }
             break;
           case Compiler.PHASE_RECOMPILING:
-            if (backend.onlyFieldIntegerSettersSoFar(left.element) &&
+            if (backend.fieldSettersTypeSoFar(left.element).isInteger() &&
                 backend.hasFieldSingleTypeInitializers(
                     left.element, HType.INTEGER)) {
               if (compiler.codegenWorld.hasInvokedSetter(left.element,
                                                          compiler)) {
                 // If there are invoked setters we don't know for sure that the
                 // field will hold an integer, but the fact that the class
                 // itself always sets an integer in the fiels is still a strong
                 // signal to indiate the expected type of the field.
                 left.propagatedType = HType.INTEGER;
                 graph.highTypeLikelyhood = true;
               } else {
                 // If there are no invoked setters we know the type of this
                 // field for sure.
                 left.guaranteedType = HType.INTEGER;
               }
             }
             break;
           default:
             assert(false);
             break;
         }
       }
     }
   }
 
 }