Extract BackendUsage, MirrorsData, and CheckedModeHelpers from Backend.

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

 // Copyright (c) 2016, 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 dart2js.mirrors_handler;
 
 import '../common.dart';
 import '../common/resolution.dart';
 import '../diagnostics/diagnostic_listener.dart';
 import '../elements/elements.dart';
@@ skipping 61 matching lines @@
   /**
    * Decides whether an element should be included to satisfy requirements
    * of the mirror system.
    *
    * During resolution, we have to resort to matching elements against the
    * [MirrorsUsed] pattern, as we do not have a complete picture of the world,
    * yet.
    */
   bool _shouldIncludeElementDueToMirrors(Element element,
       {bool includedEnclosing}) {
-    return includedEnclosing || _backend.requiredByMirrorSystem(element);
+    return includedEnclosing ||
+        _backend.mirrorsData.requiredByMirrorSystem(element);
   }
 
   /// Enqueue the constructor [ctor] if it is required for reflection.
   ///
   /// [enclosingWasIncluded] provides a hint whether the enclosing element was
   /// needed for reflection.
   void _enqueueReflectiveConstructor(ConstructorElement constructor,
       {bool enclosingWasIncluded}) {
     if (_shouldIncludeElementDueToMirrors(constructor,
         includedEnclosing: enclosingWasIncluded)) {
@@ skipping 73 matching lines @@
   /// Enqueue special classes that might not be visible by normal means or that
   /// would not normally be enqueued:
   ///
   /// [Closure] is treated specially as it is the superclass of all closures.
   /// Although it is in an internal library, we mark it as reflectable. Note
   /// that none of its methods are reflectable, unless reflectable by
   /// inheritance.
   void _enqueueReflectiveSpecialClasses() {
     Iterable<ClassElement> classes = _backend.classesRequiredForReflection;
     for (ClassElement cls in classes) {
-      if (_backend.referencedFromMirrorSystem(cls)) {
+      if (_backend.mirrorsData.referencedFromMirrorSystem(cls)) {
         _logEnqueueReflectiveAction(cls);
         cls.ensureResolved(_resolution);
         impactBuilder
             .registerTypeUse(new TypeUse.mirrorInstantiation(cls.rawType));
       }
     }
   }
 
   /// Enqueue all local members of the library [lib] if they are required for
   /// reflection.
@@ skipping 57 matching lines @@
   /// usage through `MirrorsUsed`.
   // TODO(johnniwinther): Compute [WorldImpact] instead of enqueuing directly.
   void enqueueReflectiveStaticFields(Iterable<Element> elements) {
     if (hasEnqueuedReflectiveStaticFields) return;
     hasEnqueuedReflectiveStaticFields = true;
     for (Element element in elements) {
       _enqueueReflectiveMember(element, true);
     }
   }
 }