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
     Compiler,
     CompilerTask,
     Constant,
@@ skipping 274 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(
+          compiler.backend.constantHandler.getConstantForNode(n, elements));

[floitsch, 2014/04/02 16:50:02]

Introduce backend getter in this class?

[Johnni Winther, 2014/04/07 11:42:27]

Done.

+    });
     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) {
     element = element.implementation;
     for (MetadataAnnotation metadata in element.metadata) {
-      if (metadata.value != null) {
-        constants.add(metadata.value);
-        elements.add(metadata.value.computeType(compiler).element);
+      Constant constant =
+          compiler.backend.constantHandler.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 =
+              compiler.backend.constantHandler.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 = compiler.backend.constantHandler
+                .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 128 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 157 matching lines @@
     }
     if (splitProgram && compiler.backend is DartBackend) {
       // TODO(sigurdm): Implement deferred loading for dart2dart.
       splitProgram = false;
       compiler.reportInfo(
           lastDeferred,
           MessageKind.DEFERRED_LIBRARY_DART_2_DART);
     }
   }
 }