Split backend implementation of EnqueuerListener

pkg/compiler/lib/src/js_backend/mirrors_data.dart

 // Copyright (c) 2017, 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.
 
 import '../closure.dart';
 import '../common.dart';
 import '../compiler.dart';
 import '../constants/values.dart';
 import '../elements/elements.dart';
 import '../elements/resolution_types.dart';
 import '../enqueue.dart';
+import '../options.dart';
 import '../world.dart';
 import '../util/emptyset.dart';
+import 'backend_helpers.dart';
 
 class MirrorsData {
   /// True if a call to preserveMetadataMarker has been seen.  This means that
   /// metadata must be retained for dart:mirrors to work correctly.
   bool mustRetainMetadata = false;
 
   /// True if any metadata has been retained.  This is slightly different from
   /// [mustRetainMetadata] and tells us if any metadata was retained.  For
   /// example, if [mustRetainMetadata] is true but there is no metadata in the
   /// program, this variable will stil be false.
   bool hasRetainedMetadata = false;
 
   /// True if a call to preserveLibraryNames has been seen.
   bool mustRetainLibraryNames = false;
 
   /// True if a call to preserveNames has been seen.
   bool mustPreserveNames = false;
 
   /// True if a call to disableTreeShaking has been seen.
   bool isTreeShakingDisabled = false;
 
   /// True if there isn't sufficient @MirrorsUsed data.
   bool hasInsufficientMirrorsUsed = false;
 
+  /// True if a call to preserveUris has been seen and the preserve-uris flag
+  /// is set.
+  bool mustPreserveUris = false;
+
   /// List of symbols that the user has requested for reflection.
   final Set<String> symbolsUsed = new Set<String>();
 
   /// 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>();
 
   final Compiler compiler;
 
   MirrorsData(this.compiler);
 
+  CompilerOptions get _options => compiler.options;
+
+  BackendHelpers get _helpers => compiler.backend.helpers;
+
+  void registerUsedMember(MemberElement member) {
+    if (member == _helpers.disableTreeShakingMarker) {
+      isTreeShakingDisabled = true;
+    } else if (member == _helpers.preserveNamesMarker) {
+      mustPreserveNames = true;
+    } else if (member == _helpers.preserveMetadataMarker) {
+      mustRetainMetadata = true;
+    } else if (member == _helpers.preserveUrisMarker) {
+      if (_options.preserveUris) mustPreserveUris = true;
+    } else if (member == _helpers.preserveLibraryNamesMarker) {
+      mustRetainLibraryNames = true;
+    }
+  }
+
   /// Should [element] (a getter) that would normally not be generated due to
   /// treeshaking be retained for reflection?
   bool shouldRetainGetter(Element element) {
     return isTreeShakingDisabled && isAccessibleByReflection(element);
   }
 
   /// Should [element] (a setter) hat would normally not be generated due to
   /// treeshaking be retained for reflection?
   bool shouldRetainSetter(Element element) {
     return isTreeShakingDisabled && isAccessibleByReflection(element);
@@ skipping 261 matching lines @@
       for (Element closure in closureMap[null]) {
         if (referencedFromMirrorSystem(closure)) {
           reflectableMembers.add(closure);
           foundClosure = true;
         }
       }
     }
     // As we do not think about closures as classes, yet, we have to make sure
     // their superclasses are available for reflection manually.
     if (foundClosure) {
-      ClassElement cls = compiler.backend.helpers.closureClass;
+      ClassElement cls = _helpers.closureClass;
       reflectableMembers.add(cls);
     }
     Set<Element> closurizedMembers =
         compiler.resolutionWorldBuilder.closurizedMembers;
     if (closurizedMembers.any(reflectableMembers.contains)) {
-      ClassElement cls = compiler.backend.helpers.boundClosureClass;
+      ClassElement cls = _helpers.boundClosureClass;
       reflectableMembers.add(cls);
     }
     // Add typedefs.
     reflectableMembers
         .addAll(closedWorld.allTypedefs.where(referencedFromMirrorSystem));
     // Register all symbols of reflectable elements
     for (Element element in reflectableMembers) {
       symbolsUsed.add(element.name);
     }
     _membersNeededForReflection = reflectableMembers;
@@ skipping 11 matching lines @@
   }
 
   /// Called when [:const Symbol(name):] is seen.
   void registerConstSymbol(String name) {
     symbolsUsed.add(name);
     if (name.endsWith('=')) {
       symbolsUsed.add(name.substring(0, name.length - 1));
     }
   }
 }