Use ConstExp for storing constants.

sdk/lib/_internal/compiler/implementation/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 'cps_ir/const_expression.dart';
+
 import 'dart2jslib.dart' show
     Backend,
     Compiler,
     CompilerTask,
     Constant,
     ConstructedConstant,
     MessageKind,
     DeferredConstant,
     StringConstant,
     invariant;
@@ skipping 290 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.
         addConstants(
-            backend.constants.getConstantForNode(node, treeElements));
+            backend.constants.getConstantForNode(node, treeElements).value);
       });
       elements.addAll(treeElements.otherDependencies);
     }
 
     // TODO(sigurdm): How is metadata on a patch-class handled?
     for (MetadataAnnotation metadata in element.metadata) {
-      Constant constant = backend.constants.getConstantForMetadata(metadata);
+      ConstExp constant = backend.constants.getConstantForMetadata(metadata);
       if (constant != null) {
-        addConstants(constant);
+        addConstants(constant.value);
       }
     }
     if (element.isClass) {
       // If we see a class, add everything its live instance members refer
       // to.  Static members are not relevant, unless we are processing
       // extra dependencies due to mirrors.
       void addLiveInstanceMember(Element element) {
         if (!compiler.enqueuer.resolution.isLive(element)) return;
         if (!isMirrorUsage && !element.isInstanceMember) return;
         collectDependencies(element.implementation);
@@ skipping 113 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) {
-        Constant constant =
+        ConstExp constant =
             backend.constants.getConstantForMetadata(metadata);
         if (constant != null) {
-          _mapDependencies(constant.computeType(compiler).element,
+          _mapDependencies(constant.value.computeType(compiler).element,
               deferredImport);
         }
       }
       for (LibraryTag tag in library.tags) {
         for (MetadataAnnotation metadata in tag.metadata) {
-          Constant constant =
+          ConstExp constant =
               backend.constants.getConstantForMetadata(metadata);
           if (constant != null) {
-            _mapDependencies(constant.computeType(compiler).element,
+            _mapDependencies(constant.value.computeType(compiler).element,
                 deferredImport);
           }
         }
       }
     }
 
     for (Import deferredImport in _allDeferredImports.keys) {
       LibraryElement deferredLibrary = _allDeferredImports[deferredImport];
       for (LibraryElement library in
           _nonDeferredReachableLibraries(deferredLibrary)) {
@@ skipping 13 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.value.computeType(compiler).element;
+          Element element = metadata.constant.value.computeType(compiler).element;
           if (element == deferredLibraryClass) {
-            ConstructedConstant constant = metadata.value;
+            ConstructedConstant constant = metadata.constant.value;
             StringConstant s = constant.fields[0];
             result = s.value.slowToString();
             break;
           }
         }
       }
       assert(result != null);
       importDeferName[import] = makeUnique(result, usedImportNames);;
     }
 
@@ skipping 131 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.value.computeType(compiler).element;
+              Element element =
+                  metadata.constant.value.computeType(compiler).element;
               if (element == deferredLibraryClass) {
                  compiler.reportFatalError(import, MessageKind.DEFERRED_OLD_SYNTAX);
               }
             }
           }
 
           String prefix = (import.prefix != null)
               ? import.prefix.toString()
               : null;
           // The last import we saw with the same prefix.
@@ skipping 86 matching lines @@
     Element maybePrefix = elements[identifier];
     if (maybePrefix != null && maybePrefix.isPrefix) {
       PrefixElement prefixElement = maybePrefix;
       if (prefixElement.isDeferred) {
         return prefixElement;
       }
     }
     return null;
   }
 }