Remove ConstantExpression.value

pkg/compiler/lib/src/resolution/members.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 resolution;
 
 /**
  * Core implementation of resolution.
  *
  * Do not subclass or instantiate this class outside this library
@@ skipping 1951 matching lines @@
       warning(node, MessageKind.ABSTRACT_CLASS_INSTANTIATION);
       registry.registerAbstractClassInstantiation();
     }
 
     if (isSymbolConstructor) {
       if (node.isConst) {
         Node argumentNode = node.send.arguments.head;
         ConstantExpression constant =
             compiler.resolver.constantCompiler.compileNode(
                 argumentNode, registry.mapping);
-        ConstantValue name = constant.value;
+        ConstantValue name = compiler.constants.getConstantValue(constant);
         if (!name.isString) {
           DartType type = name.getType(compiler.coreTypes);
           compiler.reportError(argumentNode, MessageKind.STRING_EXPECTED,
                                    {'type': type});
         } else {
           StringConstantValue stringConstant = name;
           String nameString = stringConstant.toDartString().slowToString();
           if (validateSymbol(argumentNode, nameString)) {
             registry.registerConstSymbol(nameString);
           }
@@ skipping 37 matching lines @@
   void analyzeConstant(Node node, {enforceConst: true}) {
     ConstantExpression constant =
         compiler.resolver.constantCompiler.compileNode(
             node, registry.mapping, enforceConst: enforceConst);
 
     if (constant == null) {
       assert(invariant(node, compiler.compilationFailed));
       return;
     }
 
-    ConstantValue value = constant.value;
+    ConstantValue value = compiler.constants.getConstantValue(constant);
     if (value.isMap) {
       checkConstMapKeysDontOverrideEquals(node, value);
     }
 
     // The type constant that is an argument to JS_INTERCEPTOR_CONSTANT names
     // a class that will be instantiated outside the program by attaching a
     // native class dispatch record referencing the interceptor.
     if (argumentsToJsInterceptorConstant != null &&
         argumentsToJsInterceptorConstant.contains(node)) {
       if (value.isType) {
@@ skipping 384 matching lines @@
       for (Node labelOrCase in switchCase.labelsAndCases) {
         CaseMatch caseMatch = labelOrCase.asCaseMatch();
         if (caseMatch == null) continue;
 
         // Analyze the constant.
         ConstantExpression constant =
             registry.getConstant(caseMatch.expression);
         assert(invariant(node, constant != null,
             message: 'No constant computed for $node'));
 
-        DartType caseType = typeOfConstant(constant.value);
+        ConstantValue value = compiler.constants.getConstantValue(constant);
+        DartType caseType = typeOfConstant(value);
 
         if (firstCaseType == null) {
           firstCase = caseMatch;
           firstCaseType = caseType;
 
           // We only report the bad type on the first class element. All others
           // get a "type differs" error.
           if (caseType.element == compiler.doubleClass) {
             compiler.reportError(node,
                                  MessageKind.SWITCH_CASE_VALUE_OVERRIDES_EQUALS,
                                  {'type': "double"});
           } else if (caseType.element == compiler.functionClass) {
             compiler.reportError(node, MessageKind.SWITCH_CASE_FORBIDDEN,
                                  {'type': "Function"});
-          } else if (constant.value.isObject && overridesEquals(caseType)) {
+          } else if (value.isObject && overridesEquals(caseType)) {
             compiler.reportError(firstCase.expression,
                 MessageKind.SWITCH_CASE_VALUE_OVERRIDES_EQUALS,
                 {'type': caseType});
           }
         } else {
           if (caseType != firstCaseType) {
             if (!hasReportedProblem) {
               compiler.reportError(
                   node,
                   MessageKind.SWITCH_CASE_TYPES_NOT_EQUAL,
@@ skipping 180 matching lines @@
   visitTypedef(Typedef node) {
     internalError(node, 'typedef');
   }
 }
 
 /// Looks up [name] in [scope] and unwraps the result.
 Element lookupInScope(Compiler compiler, Node node,
                       Scope scope, String name) {
   return Elements.unwrap(scope.lookup(name), compiler, node);
 }