Some cleanup of recompilation

lib/compiler/implementation/ssa/optimize.dart

 // Copyright (c) 2011, 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 571 matching lines @@
       isFinalOrConst = modifiers.isFinal() || modifiers.isConst();
     }
     if (!compiler.resolverWorld.hasInvokedSetter(field, compiler)) {
       // If no setter is ever used for this field it is only initialized in the
       // initializer list.
       isFinalOrConst = true;
     }
     if (!isFinalOrConst &&
         !compiler.codegenWorld.hasInvokedSetter(field, compiler) &&
         !compiler.codegenWorld.hasFieldSetter(field, compiler)) {
-      switch (compiler.pass) {
-        case 1:
+      switch (compiler.phase) {
+        case Compiler.PHASE_COMPILING:
           compiler.enqueuer.codegen.registerRecompilationCandidate(
               work.element);

[ngeoffray, 2012/06/15 20:12:59]

I think putting such considerations into the new SSA phase you introduce in
another CL might be good.

Also, since you are unconditionally recompiling once a method is in the
recompliation queue, I think this phase should return a bool telling whether the
method is a candidate for recompilation. If it says true, then compilation is
aborted. This should save some time in total compile-time.

[Søren Gjesse, 2012/06/18 06:40:36]

I will move it to the new SSA phase when it is in through another CL.

Regarding aborting compilation, then I am not sure. Most of the information used
for feedback into the recompilation is currently collected in the code
generator, so if compilation is aborted then this information will not be
collected. Maybe we should move this gathering of information out of the codegen
and have a separate step for that. We can then skip the actual codegen for
recompilation candidates. Another option will be to have some predicates on the
recompilation candidates and check these before the actual recompilation. That
way we only recompile for profit.

           break;
-        case 2:
+        case Compiler.PHASE_RECOMPILING:
           // If field is not final or const but no setters are used then the
           // field might be considered final anyway as it will be either
           // un-initialized or initialized in the constructor initializer list.
           isFinalOrConst = true;
           break;
       }
     }
     return new HFieldGet(field, node.inputs[0], isFinalOrConst: isFinalOrConst);
   }
 
@@ skipping 554 matching lines @@
         // the if block terminates. So any use of the instruction
         // after the join block should be changed to the new
         // instruction.
         changeUsesDominatedBy(ifUser.joinBlock, input, convertedType);
       }
       // TODO(ngeoffray): Also change uses for the then block on a HType
       // that knows it is not of a specific Type.
     }
   }
 }