Merge CommonElements and BackendHelpers!

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 '../common_elements.dart';
 import '../compiler.dart';
 import '../constants/values.dart';
 import '../elements/elements.dart';
 import '../elements/entities.dart';
 import '../elements/types.dart';
 import '../options.dart';
 import '../world.dart';
 import '../universe/world_builder.dart';
 import '../util/emptyset.dart';
-import 'backend_helpers.dart';
 import 'constant_handler_javascript.dart';
 
 abstract class MirrorsData {
   /// True if a call to preserveMetadataMarker has been seen.  This means that
   /// metadata must be retained for dart:mirrors to work correctly.
   // resolution-empty-queue
   bool get mustRetainMetadata;
 
   /// True if any metadata has been retained.  This is slightly different from
   /// [mustRetainMetadata] and tells us if any metadata was retained.  For
@@ skipping 173 matching lines @@
   /// element must be retained.
   final Set<ClassEntity> metaTargetsUsed = new Set<ClassEntity>();
 
   // TODO(johnniwinther): Avoid the need for this.
   final Compiler _compiler;
 
   final CompilerOptions _options;
 
   final CommonElements _commonElements;
 
-  final BackendHelpers _helpers;
-
   final JavaScriptConstantCompiler _constants;
 
-  MirrorsDataImpl(this._compiler, this._options, this._commonElements,
-      this._helpers, this._constants);
+  MirrorsDataImpl(
+      this._compiler, this._options, this._commonElements, this._constants);
 
   void registerUsedMember(MemberElement member) {
-    if (member == _helpers.disableTreeShakingMarker) {
+    if (member == _commonElements.disableTreeShakingMarker) {
       isTreeShakingDisabled = true;
-    } else if (member == _helpers.preserveNamesMarker) {
+    } else if (member == _commonElements.preserveNamesMarker) {
       mustPreserveNames = true;
-    } else if (member == _helpers.preserveMetadataMarker) {
+    } else if (member == _commonElements.preserveMetadataMarker) {
       mustRetainMetadata = true;
-    } else if (member == _helpers.preserveUrisMarker) {
+    } else if (member == _commonElements.preserveUrisMarker) {
       if (_options.preserveUris) mustPreserveUris = true;
-    } else if (member == _helpers.preserveLibraryNamesMarker) {
+    } else if (member == _commonElements.preserveLibraryNamesMarker) {
       mustRetainLibraryNames = true;
     }
   }
 
   bool shouldRetainGetter(FieldElement element) {
     return isTreeShakingDisabled && isMemberAccessibleByReflection(element);
   }
 
   bool shouldRetainSetter(FieldElement element) {
     return isTreeShakingDisabled && isMemberAccessibleByReflection(element);
@@ skipping 156 matching lines @@
     } else if (element.isClass) {
       return isClassAccessibleByReflection(element);
     } else if (element.isTypedef) {
       return isTypedefAccessibleByReflection(element);
     } else {
       return isMemberAccessibleByReflection(element);
     }
   }
 
   ClassElement _getDartClass(ClassElement cls) {
-    if (cls == _helpers.jsIntClass) {
+    if (cls == _commonElements.jsIntClass) {
       return _commonElements.intClass;
-    } else if (cls == _helpers.jsBoolClass) {
+    } else if (cls == _commonElements.jsBoolClass) {
       return _commonElements.boolClass;
-    } else if (cls == _helpers.jsNumberClass) {
+    } else if (cls == _commonElements.jsNumberClass) {
       return _commonElements.numClass;
-    } else if (cls == _helpers.jsDoubleClass) {
+    } else if (cls == _commonElements.jsDoubleClass) {
       return _commonElements.doubleClass;
-    } else if (cls == _helpers.jsStringClass) {
+    } else if (cls == _commonElements.jsStringClass) {
       return _commonElements.stringClass;
-    } else if (cls == _helpers.jsArrayClass) {
+    } else if (cls == _commonElements.jsArrayClass) {
       return _commonElements.listClass;
-    } else if (cls == _helpers.jsNullClass) {
+    } else if (cls == _commonElements.jsNullClass) {
       return _commonElements.nullClass;
     } else {
       return cls;
     }
   }
 
   bool isMemberAccessibleByReflection(MemberElement element) {
     return _membersNeededForReflection.contains(element);
   }
 
@@ skipping 221 matching lines @@
       for (LocalFunctionElement closure in closureMap[null]) {
         if (isMemberReferencedFromMirrorSystem(closure.memberContext)) {
           _closuresNeededForReflection.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 = _helpers.closureClass;
+      ClassElement cls = _commonElements.closureClass;
       _classesNeededForReflection.add(cls);
     }
     Set<FunctionEntity> closurizedMembers = worldBuilder.closurizedMembers;
     if (closurizedMembers.any(_membersNeededForReflection.contains)) {
-      ClassElement cls = _helpers.boundClosureClass;
+      ClassElement cls = _commonElements.boundClosureClass;
       _classesNeededForReflection.add(cls);
     }
     // Add typedefs.
     _typedefsNeededForReflection.addAll(
         closedWorld.allTypedefs.where(isTypedefReferencedFromMirrorSystem));
     // Register all symbols of reflectable elements
     for (ClassElement element in _classesNeededForReflection) {
       symbolsUsed.add(element.name);
     }
     for (TypedefElement element in _typedefsNeededForReflection) {
@@ skipping 19 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));
     }
   }
 }