Remove BackendClasses and JavaScriptBackendClasses.

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;
@@ skipping 97 matching lines @@
 // TODO(sigmund): detect uses of mirrors
 class LookupMapAnalysis {
   const LookupMapAnalysis._();
 
   factory LookupMapAnalysis(
       DiagnosticReporter reporter,
       ConstantSystem constantSystem,
       ConstantEnvironment constants,
       ElementEnvironment elementEnvironment,
       CommonElements commonElements,
-      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 =
         constants.getConstantValue(lookupMapVersionVariable.constant);
@@ skipping 19 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,
-        backendClasses, entriesField, keyField, valueField, typeLookupMapClass);
+    return new _LookupMapAnalysis(constantSystem, commonElements, 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.
   void registerLookupMapReference(ConstantValue lookupMap) {}
@@ skipping 16 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 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;
 
   /// The resolved [FieldElement] for `LookupMap._value`.
@@ skipping 23 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._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 24 matching lines @@
   }
 
   /// Whether we need to preserve [key]. This is true for keys that are not
   /// candidates for tree-shaking in the first place (primitives and non-type
   /// const values overriding equals) and keys that we have seen in the program.
   bool _shouldKeep(ConstantValue key) =>
       key.isPrimitive || _inUse.contains(key) || _overridesEquals(key);
 
   void _addClassUse(ClassElement cls) {
     ConstantValue key = _typeConstants.putIfAbsent(
-        cls,
-        () => _constantSystem.createType(
-            _commonElements, _backendClasses, cls.rawType));
+        cls, () => _constantSystem.createType(_commonElements, cls.rawType));
     _addUse(key);
   }
 
   /// Record that [key] is used and update every lookup map that contains it.
   void _addUse(ConstantValue key) {
     if (_inUse.add(key)) {
       _pending[key]?.forEach((info) => info._markUsed(key));
       _pending.remove(key);
     }
   }
@@ skipping 193 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');