Revert "Refactor constant part."

dart/frog/leg/emitter.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.
 
 /**
  * A function element that represents a closure call. The signature is copied
  * from the given element.
  */
 class ClosureInvocationElement extends FunctionElement {
   ClosureInvocationElement(SourceString name,
@@ skipping 53 matching lines @@
                         String attachTo(String invocationName),
                         StringBuffer buffer,
                         Selector selector,
                         bool isNative) {
     FunctionParameters parameters = member.computeParameters(compiler);
     int positionalArgumentCount = selector.positionalArgumentCount;
     if (positionalArgumentCount == parameters.parameterCount) {
       assert(selector.namedArgumentCount == 0);
       return;
     }
-    ConstantHandler handler = compiler.constantHandler;
+    CompileTimeConstantHandler constants = compiler.compileTimeConstantHandler;
     List<SourceString> names = selector.getOrderedNamedArguments();
 
     String invocationName =
         namer.instanceMethodInvocationName(member.name, selector);
     buffer.add('${attachTo(invocationName)} = function(');
 
     // The parameters that this stub takes.
     List<String> parametersBuffer = new List<String>(selector.argumentCount);
     // The arguments that will be passed to the real method.
     List<String> argumentsBuffer = new List<String>(parameters.parameterCount);
@@ skipping 41 matching lines @@
         argumentsBuffer[count] = jsName;
       } else {
         int index = names.indexOf(element.name);
         if (index != -1) {
           indexOfLastOptionalArgumentInParameters = count;
           // The order of the named arguments is not the same as the
           // one in the real method (which is in Dart source order).
           argumentsBuffer[count] = jsName;
           parametersBuffer[selector.positionalArgumentCount + index] = jsName;
         } else {
-          Constant value = handler.initialVariableValues[element];
+          Constant value = constants.initialVariableValues[element];
           if (value == null) {
             argumentsBuffer[count] = '(void 0)';
           } else {
             if (!value.isNull()) {
               // If the value is the null constant, we should not pass it
               // down to the native method.
               indexOfLastOptionalArgumentInParameters = count;
             }
             argumentsBuffer[count] =
-                handler.writeJsCode(new StringBuffer(), value).toString();
+                constants.writeJsCode(new StringBuffer(), value).toString();
           }
         }
       }
       count++;
     });
     String parametersString = Strings.join(parametersBuffer, ",");
     buffer.add('$parametersString) {\n');
 
     if (isNative) {
       nativeEmitter.emitParameterStub(
@@ skipping 311 matching lines @@
     }
   }
 
   void emitStaticNonFinalFieldInitializations(StringBuffer buffer) {
     // Adds initializations inside the Isolate constructor.
     // Example:
     //    function Isolate() {
     //       this.staticNonFinal = Isolate.prototype.someVal;
     //       ...
     //    }
-    ConstantHandler handler = compiler.constantHandler;
+    CompileTimeConstantHandler handler = compiler.compileTimeConstantHandler;
     List<VariableElement> staticNonFinalFields =
         handler.getStaticNonFinalFieldsForEmission();
     if (!staticNonFinalFields.isEmpty()) buffer.add('\n');
     for (Element element in staticNonFinalFields) {
       buffer.add('  this.${namer.getName(element)} = ');
       compiler.withCurrentElement(element, () {
           handler.writeJsCodeForVariable(buffer, element);
         });
       buffer.add(';\n');
     }
   }
 
   void emitCompileTimeConstants(StringBuffer buffer) {
-    ConstantHandler handler = compiler.constantHandler;
+    CompileTimeConstantHandler handler = compiler.compileTimeConstantHandler;
     List<Constant> constants = handler.getConstantsForEmission();
     String prototype = "${namer.ISOLATE}.prototype";
     emitMakeConstantList(prototype, buffer);
     for (Constant constant in constants) {
       String name = handler.getNameForConstant(constant);
       buffer.add('$prototype.$name = ');
       handler.writeJsCode(buffer, constant);
       buffer.add(';\n');
     }
   }
 
   void emitMakeConstantList(String prototype, StringBuffer buffer) {
     buffer.add(prototype);
     buffer.add(@'''.makeConstantList = function(list) {
   list.immutable$list = true;
   list.fixed$length = true;
   return list;
 };
 ''');
   }
 
   void emitStaticFinalFieldInitializations(StringBuffer buffer) {
-    ConstantHandler handler = compiler.constantHandler;
+    CompileTimeConstantHandler constants = compiler.compileTimeConstantHandler;
     List<VariableElement> staticFinalFields =
-        handler.getStaticFinalFieldsForEmission();
+        constants.getStaticFinalFieldsForEmission();
     for (VariableElement element in staticFinalFields) {
       buffer.add('${namer.isolatePropertyAccess(element)} = ');
       compiler.withCurrentElement(element, () {
-          handler.writeJsCodeForVariable(buffer, element);
+          constants.writeJsCodeForVariable(buffer, element);
         });
       buffer.add(';\n');
     }
   }
 
   void emitExtraAccessors(Element member,
                           String attachTo(String name),
                           StringBuffer buffer) {
     if (member.kind == ElementKind.GETTER || member.kind == ElementKind.FIELD) {
       Set<Selector> selectors = compiler.universe.invokedNames[member.name];
@@ skipping 80 matching lines @@
       emitStaticFinalFieldInitializations(buffer);
       nativeEmitter.emitDynamicDispatchMetadata(buffer);
       buffer.add('var ${namer.CURRENT_ISOLATE} = new ${namer.ISOLATE}();\n');
       Element main = compiler.mainApp.find(Compiler.MAIN);
       buffer.add('${namer.isolateAccess(main)}();\n');
       compiler.assembledCode = buffer.toString();
     });
     return compiler.assembledCode;
   }
 }