Compute frontend/backend specific 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 'dart2jslib.dart' show
+    Backend,
     Compiler,
     CompilerTask,
     Constant,
     ConstructedConstant,
     MessageKind,
     StringConstant,
     invariant;
 
 import 'dart_backend/dart_backend.dart' show
     DartBackend;
@@ skipping 125 matching lines @@
 
   // For each deferred import we want to know exactly what elements have to
   // be loaded.
   Map<Import, Set<Element>> _importedDeferredBy = null;
   Map<Import, Set<Constant>> _constantsDeferredBy = null;
 
   Set<Element> _mainElements = new Set<Element>();
 
   DeferredLoadTask(Compiler compiler) : super(compiler);
 
+  Backend get backend => compiler.backend;
+
   /// Returns the [OutputUnit] where [element] belongs.
   OutputUnit outputUnitForElement(Element element) {
     if (!splitProgram) return mainOutputUnit;
 
     element = element.implementation;
     while (!_elementToOutputUnit.containsKey(element)) {
       element = element.enclosingElement.implementation;
     }
     return _elementToOutputUnit[element];
   }
@@ skipping 122 matching lines @@
                             Set<Constant> constantDependencies) {
     TreeElements elements =
         compiler.enqueuer.resolution.getCachedElements(element);
     if (elements == null) return;
     for (Element dependency in elements.allElements) {
       if (Elements.isLocal(dependency) && !dependency.isFunction()) continue;
       if (Elements.isUnresolved(dependency)) continue;
       if (dependency.isStatement()) continue;
       elementDependencies.add(dependency);
     }
-    constantDependencies.addAll(elements.allConstants);
+    elements.forEachConstantNode((Node n, _) {
+      // Explicitly depend on the backend constants.
+      constantDependencies.add(
+          backend.constants.getConstantForNode(n, elements));
+    });
     elementDependencies.addAll(elements.otherDependencies);
   }
 
   /// Finds all elements and constants that [element] depends directly on.
   /// (not the transitive closure.)
   ///
   /// Adds the results to [elements] and [constants].
   void _collectAllElementsAndConstantsResolvedFrom(Element element,
       Set<Element> elements,
       Set<Constant> constants) {
     // TODO(sigurdm): How is metadata on a patch-class handled?
     for (MetadataAnnotation metadata in element.metadata) {
-      if (metadata.value != null) {
-        constants.add(metadata.value);
-        elements.add(metadata.value.computeType(compiler).element);
+      Constant constant = backend.constants.getConstantForMetadata(metadata);
+      if (constant != null) {
+        constants.add(constant);
+        elements.add(constant.computeType(compiler).element);
       }
     }
     if (element.isClass()) {
       // If we see a class, add everything its instance members refer
       // to.  Static members are not relevant.
       ClassElement cls = element.declaration;
       cls.forEachLocalMember((Element e) {
         if (!e.isInstanceMember()) return;
         _collectDependencies(e.implementation, elements, constants);
       });
@@ skipping 91 matching lines @@
     MirrorUsageAnalyzerTask mirrorTask = compiler.mirrorUsageAnalyzerTask;
     // For each import we record all mirrors-used elements from all the
     // libraries reached directly from that import.
     for (Import deferredImport in _allDeferredImports.keys) {
       LibraryElement deferredLibrary = _allDeferredImports[deferredImport];
       for (LibraryElement library in
           _nonDeferredReachableLibraries(deferredLibrary)) {
         // TODO(sigurdm): The metadata should go to the right output unit.
         // For now they all go to the main output unit.
         for (MetadataAnnotation metadata in library.metadata) {
-          if (metadata.value != null) {
-            _mapDependencies(metadata.value.computeType(compiler).element,
+          Constant constant =
+              backend.constants.getConstantForMetadata(metadata);
+          if (constant != null) {
+            _mapDependencies(constant.computeType(compiler).element,
                 _fakeMainImport);
           }
         }
         for (LibraryTag tag in library.tags) {
           for (MetadataAnnotation metadata in tag.metadata) {
-            if (metadata.value != null) {
-              _mapDependencies(metadata.value.computeType(compiler).element,
+            Constant constant =
+                backend.constants.getConstantForMetadata(metadata);
+            if (constant != null) {
+              _mapDependencies(constant.computeType(compiler).element,
                   _fakeMainImport);
             }
           }
         }
 
         if (mirrorTask.librariesWithUsage.contains(library)) {
 
           Map<LibraryElement, List<MirrorUsage>> mirrorsResult =
               mirrorTask.analyzer.collectMirrorsUsedAnnotation();
 
@@ skipping 148 matching lines @@
       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;
-          if (metadata.value.computeType(compiler).element ==
-              deferredLibraryClass) {
+          if (element == deferredLibraryClass) {
             ConstructedConstant constant = metadata.value;
             StringConstant s = constant.fields[0];
             result = s.value.slowToString();
             break;
           }
         }
       }
       assert(result != null);
       importDeferName[import] = makeUnique(result, usedImportNames);;
     }
@@ skipping 148 matching lines @@
                   ? previousDeferredImport
                   : import;
               compiler.reportError(failingImport.prefix,
                   MessageKind.DEFERRED_LIBRARY_DUPLICATE_PREFIX);
             }
             usedPrefixes.add(prefix);
           }
         }
       });
     }
-    if (splitProgram && compiler.backend is DartBackend) {
+    if (splitProgram && backend is DartBackend) {
       // TODO(sigurdm): Implement deferred loading for dart2dart.
       splitProgram = false;
       compiler.reportInfo(
           lastDeferred,
           MessageKind.DEFERRED_LIBRARY_DART_2_DART);
     }
   }
 }