Reapply "Refactor constant part." (r4958) with fixes.

frog/leg/compiler.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.
 
 class WorkItem {
   final Element element;
   TreeElements resolutionTree;
   Function run;
   Map<int, BailoutInfo> bailouts = null;
   bool allowSpeculativeOptimization = true;
@@ skipping 58 matching lines @@
   ScannerTask scanner;
   DietParserTask dietParser;
   ParserTask parser;
   TreeValidatorTask validator;
   ResolverTask resolver;
   TypeCheckerTask checker;
   SsaBuilderTask builder;
   SsaOptimizerTask optimizer;
   SsaCodeGeneratorTask generator;
   CodeEmitterTask emitter;
-  CompileTimeConstantHandler compileTimeConstantHandler;
+  ConstantHandler constantHandler;
 
   static final SourceString MAIN = const SourceString('main');
   static final SourceString NO_SUCH_METHOD = const SourceString('noSuchMethod');
   static final SourceString NO_SUCH_METHOD_EXCEPTION =
       const SourceString('NoSuchMethodException');
   static final SourceString OBJECT = const SourceString('Object');
   bool enabledNoSuchMethod = false;
 
   Compiler.withCurrentDirectory(String this.currentDirectory,
                                 [this.tracer = const Tracer()])
       : types = new Types(),
         universe = new Universe(),
         worklist = new Queue<WorkItem>() {
     namer = new Namer(this);
-    compileTimeConstantHandler = new CompileTimeConstantHandler(this);
+    constantHandler = new ConstantHandler(this);
     scanner = new ScannerTask(this);
     dietParser = new DietParserTask(this);
     parser = new ParserTask(this);
     validator = new TreeValidatorTask(this);
     resolver = new ResolverTask(this);
     checker = new TypeCheckerTask(this);
     builder = new SsaBuilderTask(this);
     optimizer = new SsaOptimizerTask(this);
     generator = new SsaCodeGeneratorTask(this);
     emitter = new CodeEmitterTask(this);
     tasks = [scanner, dietParser, parser, resolver, checker,
              builder, optimizer, generator,
-             emitter, compileTimeConstantHandler];
+             emitter, constantHandler];
   }
 
   void ensure(bool condition) {
     if (!condition) cancel('failed assertion in leg');
   }
 
   void unimplemented(String methodName,
                      [Node node, Token token, HInstruction instruction,
                       Element element]) {
     cancel("$methodName not implemented", node, token, instruction, element);
@@ skipping 171 matching lines @@
 
   TreeElements analyze(WorkItem work) {
     work.resolutionTree = analyzeElement(work.element);
     return work.resolutionTree;
   }
 
   String codegen(WorkItem work) {
     String code;
     if (work.element.kind == ElementKind.FIELD
         || work.element.kind == ElementKind.PARAMETER) {
-      compileTimeConstantHandler.compileWorkItem(work);
+      constantHandler.compileWorkItem(work);
       return null;
     } else {
       HGraph graph = builder.build(work);
       optimizer.optimize(work, graph);
       code = generator.generate(work, graph);
       universe.addGeneratedCode(work, code);
       return code;
     }
   }
 
@@ skipping 47 matching lines @@
   }
 
   FunctionParameters resolveSignature(FunctionElement element) {
     return withCurrentElement(element,
                               () => resolver.resolveSignature(element));
   }
 
   Object compileVariable(VariableElement element) {
     return withCurrentElement(element, () {
         compile(new WorkItem.toCompile(element));
-        return compileTimeConstantHandler.compileVariable(element);
+        return constantHandler.compileVariable(element);
       });
   }
 
   reportWarning(Node node, var message) {}
   reportError(Node node, var message) {}
 
   Script readScript(Uri uri, [ScriptTag node]) {
     unimplemented('Compiler.readScript');
   }
 
@@ skipping 46 matching lines @@
 
 // TODO(ahe): Remove when the VM supports implicit interfaces.
 class LTracer implements Tracer {
   const LTracer();
   final bool enabled = false;
   void traceGraph(String name, var graph) {
   }
   void close() {
   }
 }