Remove ConstantExpression.value

pkg/compiler/lib/src/deferred_load.dart

 // Copyright (c) 2014, 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.
 
 library deferred_load;
 
 import 'constants/expressions.dart';
 import 'constants/values.dart' show
     ConstantValue,
     ConstructedConstantValue,
@@ skipping 269 matching lines @@
       for (Element dependency in treeElements.allElements) {
         if (dependency.isLocal && !dependency.isFunction) continue;
         if (dependency.isErroneous) continue;
         if (dependency.isTypeVariable) continue;
 
         elements.add(dependency);
       }
       treeElements.forEachConstantNode((Node node, _) {
         // Explicitly depend on the backend constants.
         constants.add(
-            backend.constants.getConstantForNode(node, treeElements).value);
+            backend.constants.getConstantValueForNode(node, treeElements));
       });
       elements.addAll(treeElements.otherDependencies);
     }
 
     // TODO(sigurdm): How is metadata on a patch-class handled?
     for (MetadataAnnotation metadata in element.metadata) {
-      ConstantExpression constant =
-          backend.constants.getConstantForMetadata(metadata);
+      ConstantValue constant =
+          backend.constants.getConstantValueForMetadata(metadata);
       if (constant != null) {
-        constants.add(constant.value);
+        constants.add(constant);
       }
     }
 
     collectTypeDependencies(DartType type) {
       if (type is FunctionType) {
         for (DartType argumentType in type.parameterTypes) {
           collectTypeDependencies(argumentType);
         }
         for (DartType argumentType in type.optionalParameterTypes) {
           collectTypeDependencies(argumentType);
@@ skipping 173 matching lines @@
     }
 
     // For each deferred import we analyze all elements reachable from the
     // imported library through non-deferred imports.
     handleLibrary(LibraryElement library, Import deferredImport) {
       library.implementation.forEachLocalMember((Element element) {
         mapDependenciesIfResolved(element, deferredImport);
       });
 
       for (MetadataAnnotation metadata in library.metadata) {
-        ConstantExpression constant =
-            backend.constants.getConstantForMetadata(metadata);
+        ConstantValue constant =
+            backend.constants.getConstantValueForMetadata(metadata);
         if (constant != null) {
-          _mapConstantDependencies(constant.value,
-                                   deferredImport);
+          _mapConstantDependencies(constant, deferredImport);
         }
       }
       for (LibraryTag tag in library.tags) {
         for (MetadataAnnotation metadata in tag.metadata) {
-          ConstantExpression constant =
-              backend.constants.getConstantForMetadata(metadata);
+          ConstantValue constant =
+              backend.constants.getConstantValueForMetadata(metadata);
           if (constant != null) {
-            _mapConstantDependencies(constant.value,
-                                     deferredImport);
+            _mapConstantDependencies(constant, deferredImport);
           }
         }
       }
     }
 
     for (Import deferredImport in _allDeferredImports.keys) {
       LibraryElement deferredLibrary = _allDeferredImports[deferredImport];
       for (LibraryElement library in
           _nonDeferredReachableLibraries(deferredLibrary)) {
         handleLibrary(library, deferredImport);
@@ skipping 12 matching lines @@
       String result;
       if (import == _fakeMainImport) {
         result = "main";
       } else if (import.isDeferred) {
         result = import.prefix.toString();
       } else {
         Link<MetadataAnnotation> metadatas = import.metadata;
         assert(metadatas != null);
         for (MetadataAnnotation metadata in metadatas) {
           metadata.ensureResolved(compiler);
-          Element element =
-              metadata.constant.value.getType(compiler.coreTypes).element;
+          ConstantValue value =
+              compiler.constants.getConstantValue(metadata.constant);
+          Element element = value.getType(compiler.coreTypes).element;
           if (element == deferredLibraryClass) {
-            ConstructedConstantValue constant = metadata.constant.value;
+            ConstructedConstantValue constant = value;
             StringConstantValue s = constant.fields.values.single;
             result = s.primitiveValue.slowToString();
             break;
           }
         }
       }
       assert(result != null);
       importDeferName[import] = makeUnique(result, usedImportNames);;
     }
 
@@ skipping 166 matching lines @@
         // instead of a Link.
         for (LibraryTag tag in library.tags) {
           if (tag is! Import) continue;
           Import import = tag;
 
           /// Give an error if the old annotation-based syntax has been used.
           Link<MetadataAnnotation> metadataList = import.metadata;
           if (metadataList != null) {
             for (MetadataAnnotation metadata in metadataList) {
               metadata.ensureResolved(compiler);
-              Element element =
-                  metadata.constant.value.getType(compiler.coreTypes).element;
+              ConstantValue value =
+                  compiler.constants.getConstantValue(metadata.constant);
+              Element element = value.getType(compiler.coreTypes).element;
               if (element == deferredLibraryClass) {
                  compiler.reportError(
                      import, MessageKind.DEFERRED_OLD_SYNTAX);
               }
             }
           }
 
           String prefix = (import.prefix != null)
               ? import.prefix.toString()
               : null;
@@ skipping 148 matching lines @@
         _importingLibrary = importingLibrary;
 
   String get importingLibraryName {
     String libraryName = _importingLibrary.getLibraryName();
     return libraryName == ""
       ? "<unnamed>"
       : libraryName;
   }
 
 }