Revert "Remove Registry from registerMetadataConstant" and "Serialize metadata"

pkg/compiler/lib/src/js_backend/backend.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 js_backend;
 
 const VERBOSE_OPTIMIZER_HINTS = false;
 
 class JavaScriptItemCompilationContext extends ItemCompilationContext {
   final Set<HInstruction> boundsChecked = new Set<HInstruction>();
@@ skipping 431 matching lines @@
   /// True if a core-library function requires the preamble file to function.
   bool requiresPreamble = false;
 
   /// True if the html library has been loaded.
   bool htmlLibraryIsLoaded = false;
 
   /// List of constants from metadata.  If metadata must be preserved,
   /// these constants must be registered.
   final List<Dependency> metadataConstants = <Dependency>[];
 
-  /// Set of elements for which metadata has been registered as dependencies.
-  final Set<Element> _registeredMetadata = new Set<Element>();
-
   /// List of elements that the user has requested for reflection.
   final Set<Element> targetsUsed = new Set<Element>();
 
   /// List of annotations provided by user that indicate that the annotated
   /// element must be retained.
   final Set<Element> metaTargetsUsed = new Set<Element>();
 
   /// Set of methods that are needed by reflection. Computed using
   /// [computeMembersNeededForReflection] on first use.
   Set<Element> _membersNeededForReflection = null;
@@ skipping 585 matching lines @@
         // helper so we register a use of that.
         registry.registerStaticUse(new StaticUse.staticInvoke(
             // TODO(johnniwinther): Find the right [CallStructure].
 
             helpers.createRuntimeType,
             null));
       }
     }
   }
 
+  void registerMetadataConstant(MetadataAnnotation metadata,
+      Element annotatedElement, Registry registry) {
+    assert(registry.isForResolution);
+    ConstantValue constant = constants.getConstantValueForMetadata(metadata);
+    registerCompileTimeConstant(constant, registry);
+    metadataConstants.add(new Dependency(constant, annotatedElement));
+  }
+
   void registerInstantiatedClass(
       ClassElement cls, Enqueuer enqueuer, Registry registry) {
     _processClass(cls, enqueuer, registry);
   }
 
   void registerImplementedClass(
       ClassElement cls, Enqueuer enqueuer, Registry registry) {
     _processClass(cls, enqueuer, registry);
   }
 
@@ skipping 190 matching lines @@
       enqueueInResolution(traceHelper, registry);
     }
     enqueueInResolution(helpers.assertUnreachableMethod, registry);
     registerCheckedModeHelpers(registry);
   }
 
   onResolutionComplete() {
     super.onResolutionComplete();
     computeMembersNeededForReflection();
     rti.computeClassesNeedingRti();
-    _registeredMetadata.clear();
   }
 
   onTypeInferenceComplete() {
     super.onTypeInferenceComplete();
     noSuchMethodRegistry.onTypeInferenceComplete();
   }
 
   void registerGetRuntimeTypeArgument(Registry registry) {
     enqueueImpact(
         compiler.enqueuer.resolution, impacts.getRuntimeTypeArgument, registry);
@@ skipping 1012 matching lines @@
       // necessary, but the backend relies on them being resolved.
       enqueuer.enqueueReflectiveStaticFields(_findStaticFieldTargets());
     }
 
     if (mustPreserveNames) reporter.log('Preserving names.');
 
     if (mustRetainMetadata) {
       reporter.log('Retaining metadata.');
 
       compiler.libraryLoader.libraries.forEach(retainMetadataOf);
-
-      if (enqueuer.isResolutionQueue) {
-        /// Register the constant value of [metadata] as live in resolution.
-        void registerMetadataConstant(MetadataAnnotation metadata) {
-          ConstantValue constant =
-              constants.getConstantValueForMetadata(metadata);
-          Dependency dependency =
-              new Dependency(constant, metadata.annotatedElement);
-          metadataConstants.add(dependency);
-          registerCompileTimeConstant(dependency.constant,
-              new EagerRegistry('EagerRegistry for ${dependency}', enqueuer));
-        }
-
-        // TODO(johnniwinther): We should have access to all recently processed
-        // elements and process these instead.
-        processMetadata(compiler.enqueuer.resolution.processedElements,
-            registerMetadataConstant);
-      } else {
-        for (Dependency dependency in metadataConstants) {
-          registerCompileTimeConstant(dependency.constant,
-              new EagerRegistry('EagerRegistry for ${dependency}', enqueuer));
-        }
+      for (Dependency dependency in metadataConstants) {
+        registerCompileTimeConstant(dependency.constant,
+            new EagerRegistry('EagerRegistry for ${dependency}', enqueuer));
+      }
+      if (!enqueuer.isResolutionQueue) {
         metadataConstants.clear();
       }
     }
     return true;
   }
 
-  /// Call [registerMetadataConstant] on all metadata from [elements].
-  void processMetadata(Iterable<Element> elements,
-      void onMetadata(MetadataAnnotation metadata)) {
-    void processLibraryMetadata(LibraryElement library) {
-      if (_registeredMetadata.add(library)) {
-        library.metadata.forEach(onMetadata);
-        for (ImportElement import in library.imports) {
-          import.metadata.forEach(onMetadata);
-        }
-      }
-    }
-
-    void processElementMetadata(Element element) {
-      if (_registeredMetadata.add(element)) {
-        element.metadata.forEach(onMetadata);
-        if (element.enclosingClass != null) {
-          processElementMetadata(element.enclosingClass);
-        } else {
-          processLibraryMetadata(element.library);
-        }
-      }
-    }
-
-    elements.forEach(processElementMetadata);
-  }
-
   void onQueueClosed() {
     lookupMapAnalysis.onQueueClosed();
     jsInteropAnalysis.onQueueClosed();
   }
 
   void onCodegenStart() {
     lookupMapAnalysis.onCodegenStart();
   }
 
   @override
@@ skipping 702 matching lines @@
     return transformed;
   }
 }
 
 /// Records that [constant] is used by the element behind [registry].
 class Dependency {
   final ConstantValue constant;
   final Element annotatedElement;
 
   const Dependency(this.constant, this.annotatedElement);
-
-  String toString() => '$annotatedElement:${constant.toStructuredText()}';
 }
 
 class JavaScriptImpactStrategy extends ImpactStrategy {
   final Resolution resolution;
   final DumpInfoTask dumpInfoTask;
   final bool supportDeferredLoad;
   final bool supportDumpInfo;
   final bool supportSerialization;
 
   JavaScriptImpactStrategy(this.resolution, this.dumpInfoTask,
@@ skipping 25 matching lines @@
 
   @override
   void onImpactUsed(ImpactUseCase impactUse) {
     if (impactUse == DeferredLoadTask.IMPACT_USE && !supportSerialization) {
       // TODO(johnniwinther): Allow emptying when serialization has been
       // performed.
       resolution.emptyCache();
     }
   }
 }