Merge CommonElements and BackendHelpers!

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

 // Copyright (c) 2015, 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.
 
 /// Analysis to determine how to generate code for `LookupMap`s.
 library compiler.src.js_backend.lookup_map_analysis;
 
 import 'package:pub_semver/pub_semver.dart';
 
 import '../common.dart';
 import '../common_elements.dart';
 import '../common/backend_api.dart';
 import '../compile_time_constants.dart';
 import '../constants/constant_system.dart';
 import '../constants/values.dart'
     show
         ConstantValue,
         ConstructedConstantValue,
         ListConstantValue,
         NullConstantValue,
         StringConstantValue,
         TypeConstantValue;
 import '../elements/elements.dart' show ClassElement, FieldElement;
 import '../elements/entities.dart';
 import '../elements/resolution_types.dart' show ResolutionInterfaceType;
 import '../universe/use.dart' show ConstantUse, StaticUse;
 import '../universe/world_impact.dart'
     show WorldImpact, StagedWorldImpactBuilder;
-import 'backend_helpers.dart';
 
 /// Lookup map handling for resolution.
 ///
 /// This analysis checks for the import of `package:lookup_map/lookup_map.dart`,
 /// and if found, read the `_version` variable from it.
 ///
 /// In [LookupMapAnalysis] the value of `_version` is checked to ensure that it
 /// is valid to perform the optimization of `LookupMap`. The actual optimization
 /// is performed by [LookupMapAnalysis].
 class LookupMapResolutionAnalysis {
@@ skipping 81 matching lines @@
 // TODO(sigmund): detect uses of mirrors
 class LookupMapAnalysis {
   const LookupMapAnalysis._();
 
   factory LookupMapAnalysis(
       DiagnosticReporter reporter,
       ConstantSystem constantSystem,
       ConstantEnvironment constants,
       ElementEnvironment elementEnvironment,
       CommonElements commonElements,
-      BackendHelpers helpers,
       BackendClasses backendClasses,
       LookupMapResolutionAnalysis analysis) {
     /// Checks if the version of lookup_map is valid, and if so, enable this
     /// analysis during codegen.
     FieldElement lookupMapVersionVariable = analysis.lookupMapVersionVariable;
     if (lookupMapVersionVariable == null) return const LookupMapAnalysis._();
 
     // At this point, the lookupMapVersionVariable should be resolved and it's
     // constant value should be available.
     StringConstantValue value =
@@ skipping 20 matching lines @@
     ClassEntity typeLookupMapClass =
         elementEnvironment.lookupClass(analysis.lookupMapLibrary, 'LookupMap');
     FieldElement entriesField =
         elementEnvironment.lookupClassMember(typeLookupMapClass, '_entries');
     FieldElement keyField =
         elementEnvironment.lookupClassMember(typeLookupMapClass, '_key');
     FieldElement valueField =
         elementEnvironment.lookupClassMember(typeLookupMapClass, '_value');
     // TODO(sigmund): Maybe inline nested maps to make the output code smaller?
 
-    return new _LookupMapAnalysis(constantSystem, commonElements, helpers,
+    return new _LookupMapAnalysis(constantSystem, commonElements,
         backendClasses, entriesField, keyField, valueField, typeLookupMapClass);
   }
 
   /// Compute the [WorldImpact] for the constants registered since last flush.
   WorldImpact flush() => const WorldImpact();
 
   /// Whether [constant] is an instance of a `LookupMap`.
   bool isLookupMap(ConstantValue constant) => false;
 
   /// Registers an instance of a lookup-map with the analysis.
@@ skipping 17 matching lines @@
 }
 
 class _LookupMapAnalysis implements LookupMapAnalysis {
   static final Uri PACKAGE_LOOKUP_MAP =
       new Uri(scheme: 'package', path: 'lookup_map/lookup_map.dart');
 
   final ConstantSystem _constantSystem;
 
   final CommonElements _commonElements;
 
-  final BackendHelpers _helpers;
-
   final BackendClasses _backendClasses;
 
   /// The resolved [ClassElement] associated with `LookupMap`.
   final ClassElement _typeLookupMapClass;
 
   /// The resolved [FieldElement] for `LookupMap._entries`.
   final FieldElement _entriesField;
 
   /// The resolved [FieldElement] for `LookupMap._key`.
   final FieldElement _keyField;
@@ skipping 25 matching lines @@
   /// that we haven't seen, we record the list of lookup-maps that contain an
   /// entry with that key.
   final _pending = <ConstantValue, List<_LookupMapInfo>>{};
 
   final StagedWorldImpactBuilder _impactBuilder =
       new StagedWorldImpactBuilder();
 
   _LookupMapAnalysis(
       this._constantSystem,
       this._commonElements,
-      this._helpers,
       this._backendClasses,
       this._entriesField,
       this._keyField,
       this._valueField,
       this._typeLookupMapClass);
 
   /// Compute the [WorldImpact] for the constants registered since last flush.
   WorldImpact flush() {
     return _impactBuilder.flush();
   }
@@ skipping 76 matching lines @@
   void _addGenerics(ResolutionInterfaceType type) {
     if (!type.isGeneric) return;
     for (var arg in type.typeArguments) {
       if (arg is ResolutionInterfaceType) {
         _addClassUse(arg.element);
         // Note: this call was needed to generate correct code for
         // type_lookup_map/generic_type_test
         // TODO(sigmund): can we get rid of this?
         _impactBuilder.registerStaticUse(new StaticUse.staticInvoke(
             // TODO(johnniwinther): Find the right [CallStructure].
-            _helpers.createRuntimeType,
+            _commonElements.createRuntimeType,
             null));
         _addGenerics(arg);
       }
     }
   }
 
   /// Callback from the codegen enqueuer, invoked when a constant (which is
   /// possibly a const key or a type literal) is used in the program.
   void registerTypeConstant(ClassElement element) {
     _addClassUse(element);
@@ skipping 144 matching lines @@
         original.fields[analysis._valueField] = keyValuePairs[1];
       }
     } else {
       original.fields[analysis._entriesField] =
           new ListConstantValue(listType, keyValuePairs);
     }
   }
 }
 
 final _validLookupMapVersionConstraint = new VersionConstraint.parse('^0.0.1');