Compute frontend/backend specific constants.

sdk/lib/_internal/compiler/implementation/js_emitter/container_builder.dart

 // Copyright (c) 2013, 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.
 
 part of dart2js.js_emitter;
 
 /// This class should morph into something that makes it easy to build
 /// JavaScript representations of libraries, class-sides, and instance-sides.
 /// Initially, it is just a placeholder for code that is moved from
 /// [CodeEmitterTask].
@@ skipping 25 matching lines @@
       assert(selector.namedArgumentCount == 0);
       return;
     }
     if (parameters.optionalParametersAreNamed
         && selector.namedArgumentCount == parameters.optionalParameterCount) {
       // If the selector has the same number of named arguments as the element,
       // we don't need to add a stub. The call site will hit the method
       // directly.
       return;
     }
-    ConstantHandler handler = compiler.constantHandler;
+    JavaScriptConstantCompiler handler = backend.constants;
     List<String> names = selector.getOrderedNamedArguments();
 
     String invocationName = namer.invocationName(selector);
     if (alreadyGenerated.contains(invocationName)) return;
     alreadyGenerated.add(invocationName);
 
     bool isInterceptedMethod = backend.isInterceptedMethod(member);
 
     // If the method is intercepted, we need to also pass the actual receiver.
     int extraArgumentCount = isInterceptedMethod ? 1 : 0;
@@ skipping 35 matching lines @@
       } 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] = js(jsName);
           parametersBuffer[optionalParameterStart + index] =
               new jsAst.Parameter(jsName);
         } else {
-          Constant value = handler.initialVariableValues[element];
+          Constant value = handler.getConstantForVariable(element);
           if (value == null) {
             argumentsBuffer[count] = task.constantReference(new NullConstant());
           } 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] = task.constantReference(value);
           }
@@ skipping 385 matching lines @@
         ..add(optionalParameterCount)
         ..add(memberTypeExpression)
         ..addAll(task.metadataEmitter.reifyDefaultArguments(member));
 
     if (canBeReflected || canBeApplied) {
       parameters.forEachParameter((Element parameter) {
         expressions.add(task.metadataEmitter.reifyName(parameter.name));
         if (backend.mustRetainMetadata) {
           List<MetadataAnnotation> annotations = parameter.metadata.toList();
           Iterable<int> metadataIndices =
-              annotations.map((MetadataAnnotation a) {
-            compiler.constantHandler.addCompileTimeConstantForEmission(a.value);
-            return task.metadataEmitter.reifyMetadata(a);
+              annotations.map((MetadataAnnotation annotation) {
+            Constant constant =
+                backend.constants.getConstantForMetadata(annotation);
+            backend.constants.addCompileTimeConstantForEmission(constant);
+            return task.metadataEmitter.reifyMetadata(annotation);
           });
           expressions.add(metadataIndices.isNotEmpty ? metadataIndices.toList()
                                                      : js('[]'));
         }
       });
     }
     if (canBeReflected) {
       jsAst.LiteralString reflectionName;
       if (member.isConstructor()) {
         String reflectionNameString = task.getReflectionName(member, name);
@@ skipping 10 matching lines @@
       expressions.add(js.string(member.name));
     }
 
     builder.addProperty(name, js.toExpression(expressions));
   }
 
   void addMemberField(VariableElement member, ClassBuilder builder) {
     // For now, do nothing.
   }
 }