Revert "Compute frontend/backend specific constants."

sdk/lib/_internal/compiler/implementation/ssa/builder.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.
 
 part of ssa;
 
 /**
  * A special element for the extra parameter taken by intercepted
  * methods. We need to implement [TypedElement.type] because our
  * optimizers may look at its declared type.
@@ skipping 45 matching lines @@
         } else {
           compiler.internalError(element, 'Unexpected element kind $kind.');
         }
         assert(graph.isValid());
         if (!identical(kind, ElementKind.FIELD)) {
           FunctionElement function = element;
           FunctionSignature signature = function.functionSignature;
           signature.forEachOptionalParameter((Element parameter) {
             // This ensures the default value will be computed.
             Constant constant =
-                backend.constants.getConstantForVariable(parameter);
+                compiler.constantHandler.getConstantForVariable(parameter);
             backend.registerCompileTimeConstant(constant, work.resolutionTree);
-            backend.constants.addCompileTimeConstantForEmission(constant);
+            compiler.constantHandler.addCompileTimeConstantForEmission(
+                constant);
           });
         }
         if (compiler.tracer.enabled) {
           String name;
           if (element.isMember()) {
             String className = element.getEnclosingClass().name;
             String memberName = element.name;
             name = "$className.$memberName";
             if (element.isGenerativeConstructorBody()) {
               name = "$name (body)";
@@ skipping 1223 matching lines @@
       // The [sourceElementStack] contains declaration elements.
       sourceElementStack.add(element.declaration);
       var result = f();
       sourceElementStack.removeLast();
       return result;
     });
   }
 
   HInstruction handleConstantForOptionalParameter(Element parameter) {
     Constant constant =
-        backend.constants.getConstantForVariable(parameter);
+        compiler.constantHandler.getConstantForVariable(parameter);
     assert(invariant(parameter, constant != null,
         message: 'No constant computed for $parameter'));
     return graph.addConstant(constant, compiler);
   }
 
   Element get currentNonClosureClass {
     ClassElement cls = sourceElement.getEnclosingClass();
     if (cls != null && cls.isClosure()) {
       var closureClass = cls;
       return closureClass.methodElement.getEnclosingClass();
@@ skipping 18 matching lines @@
   final List<DartType> currentInlinedInstantiations = <DartType>[];
 
   final List<AstInliningState> inliningStack = <AstInliningState>[];
 
   Element returnElement;
   DartType returnType;
 
   bool inTryStatement = false;
 
   Constant getConstantForNode(ast.Node node) {
-    Constant constant =
-        backend.constants.getConstantForNode(node, elements);
+    Constant constant = elements.getConstant(node);
     assert(invariant(node, constant != null,
         message: 'No constant computed for $node'));
     return constant;
   }
 
   HInstruction addConstant(ast.Node node) {
     return graph.addConstant(getConstantForNode(node), compiler);
   }
 
   bool isLazilyInitialized(VariableElement element) {
     Constant initialValue =
-        backend.constants.getConstantForVariable(element);
+        compiler.constantHandler.getConstantForVariable(element);
     return initialValue == null;
   }
 
   TypeMask cachedTypeOfThis;
 
   TypeMask getTypeOfThis() {
     TypeMask result = cachedTypeOfThis;
     if (result == null) {
       Element element = localsHandler.closureData.thisElement;
       ClassElement cls = element.enclosingElement.getEnclosingClass();
@@ skipping 1555 matching lines @@
   }
 
   void generateGetter(ast.Send send, Element element) {
     if (element != null && element.isForeign(compiler)) {
       visitForeignGetter(send);
     } else if (Elements.isStaticOrTopLevelField(element)) {
       Constant value;
       if (element.isField() && !element.isAssignable()) {
         // A static final or const. Get its constant value and inline it if
         // the value can be compiled eagerly.
-        value = backend.constants.getConstantForVariable(element);
+        value = compiler.constantHandler.getConstantForVariable(element);
       }
       if (value != null) {
         HConstant instruction = graph.addConstant(value, compiler);
         stack.add(instruction);
         // The inferrer may have found a better type than the constant
         // handler in the case of lists, because the constant handler
         // does not look at elements in the list.
         TypeMask type =
             TypeMaskFactory.inferredTypeForElement(element, compiler);
         if (!type.containsAll(compiler) && !instruction.isConstantNull()) {
@@ skipping 1383 matching lines @@
         generateThrowNoSuchMethod(node.send,
                                   getTargetName(error, 'constructor'),
                                   argumentNodes: node.send.arguments);
       } else {
         Message message = error.messageKind.message(error.messageArguments);
         generateRuntimeError(node.send, message.toString());
       }
     } else if (node.isConst()) {
       stack.add(addConstant(node));
       if (isSymbolConstructor) {
-        ConstructedConstant symbol = getConstantForNode(node);
+        ConstructedConstant symbol = elements.getConstant(node);
         StringConstant stringConstant = symbol.fields.single;
         String nameString = stringConstant.toDartString().slowToString();
         compiler.enqueuer.codegen.registerConstSymbol(nameString, elements);
       }
     } else {
       handleNewSend(node);
     }
   }
 
   void pushInvokeDynamic(ast.Node node,
@@ skipping 1861 matching lines @@
     DartType unaliased = type.unalias(builder.compiler);
     if (unaliased is TypedefType) throw 'unable to unalias $type';
     unaliased.accept(this, builder);
   }
 
   void visitDynamicType(DynamicType type, SsaBuilder builder) {
     ClassElement cls = builder.compiler.findHelper('DynamicRuntimeType');
     builder.push(new HDynamicType(type, new TypeMask.exact(cls)));
   }
 }