Use ConstExp for storing 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 synthetic local variable only used with the SSA graph.
 ///
 /// For instance used for holding return value of function or the exception of a
 /// try-catch statement.
@@ skipping 41 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((ParameterElement parameter) {
             // This ensures the default value will be computed.
             Constant constant =
-                backend.constants.getConstantForVariable(parameter);
+                backend.constants.getConstantForVariable(parameter).value;
             CodegenRegistry registry = work.registry;
             registry.registerCompileTimeConstant(constant);
           });
         }
         if (compiler.tracer.isEnabled) {
           String name;
           if (element.isClassMember) {
             String className = element.enclosingClass.name;
             String memberName = element.name;
             name = "$className.$memberName";
@@ skipping 1266 matching lines @@
     return compiler.withCurrentElement(element, () {
       // The [sourceElementStack] contains declaration elements.
       sourceElementStack.add(element.declaration);
       var result = f();
       sourceElementStack.removeLast();
       return result;
     });
   }
 
   HInstruction handleConstantForOptionalParameter(Element parameter) {
-    Constant constant =
+    ConstExp constant =
         backend.constants.getConstantForVariable(parameter);
     assert(invariant(parameter, constant != null,
         message: 'No constant computed for $parameter'));
-    return graph.addConstant(constant, compiler);
+    return graph.addConstant(constant.value, compiler);
   }
 
   Element get currentNonClosureClass {
     ClassElement cls = sourceElement.enclosingClass;
     if (cls != null && cls.isClosure) {
       var closureClass = cls;
       return closureClass.methodElement.enclosingClass;
     } else {
       return cls;
     }
@@ skipping 15 matching lines @@
   final List<DartType> currentInlinedInstantiations = <DartType>[];
 
   final List<AstInliningState> inliningStack = <AstInliningState>[];
 
   Local returnLocal;
   DartType returnType;
 
   bool inTryStatement = false;
 
   Constant getConstantForNode(ast.Node node) {
-    Constant constant =
+    ConstExp constant =
         backend.constants.getConstantForNode(node, elements);
     assert(invariant(node, constant != null,
         message: 'No constant computed for $node'));
-    return constant;
+    return constant.value;
   }
 
   HInstruction addConstant(ast.Node node) {
     return graph.addConstant(getConstantForNode(node), compiler);
   }
 
   bool isLazilyInitialized(VariableElement element) {
-    Constant initialValue =
+    ConstExp initialValue =
         backend.constants.getConstantForVariable(element);
     return initialValue == null;
   }
 
   TypeMask cachedTypeOfThis;
 
   TypeMask getTypeOfThis() {
     TypeMask result = cachedTypeOfThis;
     if (result == null) {
       ThisLocal local = localsHandler.closureData.thisLocal;
@@ skipping 1654 matching lines @@
       Element helper = backend.getCheckDeferredIsLoaded();
       pushInvokeStatic(node, helper, [loadIdConstant, uriConstant]);
       pop();
     }
   }
 
   void generateGetter(ast.Send send, Element element) {
     if (element != null && element.isForeign(backend)) {
       visitForeignGetter(send);
     } else if (Elements.isStaticOrTopLevelField(element)) {
-      Constant value;
+      ConstExp constant;
       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);
+        constant = backend.constants.getConstantForVariable(element);
       }
-      if (value != null) {
+      if (constant != null) {
+        Constant value = constant.value;
         HConstant instruction;
         // Constants that are referred via a deferred prefix should be referred
         // by reference.
         PrefixElement prefix = compiler.deferredLoadTask
             .deferredPrefixElement(send, elements);
         if (prefix != null) {
           instruction = graph.addDeferredConstant(value, prefix, compiler);
         } else {
           instruction = graph.addConstant(value, compiler);
         }
@@ skipping 3440 matching lines @@
     if (unaliased is TypedefType) throw 'unable to unalias $type';
     unaliased.accept(this, builder);
   }
 
   void visitDynamicType(DynamicType type, SsaBuilder builder) {
     JavaScriptBackend backend = builder.compiler.backend;
     ClassElement cls = backend.findHelper('DynamicRuntimeType');
     builder.push(new HDynamicType(type, new TypeMask.exact(cls, classWorld)));
   }
 }