Remove BackendClasses and JavaScriptBackendClasses.

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

 // Copyright (c) 2012, 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.constant_system.js;
 
-import '../common/backend_api.dart' show BackendClasses;
 import '../constant_system_dart.dart';
 import '../constants/constant_system.dart';
 import '../constants/values.dart';
 import '../common_elements.dart' show CommonElements;
 import '../elements/types.dart';
 import '../elements/resolution_types.dart' show DartTypes;
 import '../elements/entities.dart';
 import '../tree/dartstring.dart' show DartString, LiteralDartString;
 
 const JAVA_SCRIPT_CONSTANT_SYSTEM = const JavaScriptConstantSystem();
@@ skipping 293 matching lines @@
 
   BoolConstantValue createBool(bool value) => new BoolConstantValue(value);
   NullConstantValue createNull() => new NullConstantValue();
 
   @override
   ListConstantValue createList(InterfaceType type, List<ConstantValue> values) {
     return new ListConstantValue(type, values);
   }
 
   @override
-  ConstantValue createType(CommonElements commonElements,
-      BackendClasses backendClasses, DartType type) {
-    InterfaceType instanceType = backendClasses.typeType;
+  ConstantValue createType(CommonElements commonElements, DartType type) {
+    InterfaceType instanceType = commonElements.typeLiteralType;
     return new TypeConstantValue(type, instanceType);
   }
 
   // Integer checks report true for -0.0, INFINITY, and -INFINITY.  At
   // runtime an 'X is int' check is implemented as:
   //
   // typeof(X) === "number" && Math.floor(X) === X
   //
   // We consistently match that runtime semantics at compile time as well.
   bool isInt(ConstantValue constant) {
@@ skipping 16 matching lines @@
     // which will return true for both integers and doubles.
     if (s == types.commonElements.intType &&
         t == types.commonElements.doubleType) {
       return true;
     }
     return types.isSubtype(s, t);
   }
 
   MapConstantValue createMap(
       CommonElements commonElements,
-      BackendClasses backendClasses,
       InterfaceType sourceType,
       List<ConstantValue> keys,
       List<ConstantValue> values) {
     bool onlyStringKeys = true;
     ConstantValue protoValue = null;
     for (int i = 0; i < keys.length; i++) {
       var key = keys[i];
       if (key.isString) {
         if (key.primitiveValue == JavaScriptMapConstant.PROTO_PROPERTY) {
           protoValue = values[i];
         }
       } else {
         onlyStringKeys = false;
         // Don't handle __proto__ values specially in the general map case.
         protoValue = null;
         break;
       }
     }
 
     bool hasProtoKey = (protoValue != null);
     InterfaceType keysType;
     if (sourceType.treatAsRaw) {
       keysType = commonElements.listType();
     } else {
       keysType = commonElements.listType(sourceType.typeArguments.first);
     }
     ListConstantValue keysList = new ListConstantValue(keysType, keys);
-    InterfaceType type = backendClasses.getConstantMapTypeFor(sourceType,
+    InterfaceType type = commonElements.getConstantMapTypeFor(sourceType,
         hasProtoKey: hasProtoKey, onlyStringKeys: onlyStringKeys);
     return new JavaScriptMapConstant(
         type, keysList, values, protoValue, onlyStringKeys);
   }
 
   @override
-  ConstantValue createSymbol(CommonElements commonElements,
-      BackendClasses backendClasses, String text) {
-    InterfaceType type = backendClasses.symbolType;
-    FieldEntity field = backendClasses.symbolField;
+  ConstantValue createSymbol(CommonElements commonElements, String text) {
+    InterfaceType type = commonElements.symbolImplementationType;
+    FieldEntity field = commonElements.symbolField;
     ConstantValue argument = createString(new DartString.literal(text));
     // TODO(johnniwinther): Use type arguments when all uses no longer expect
     // a [FieldElement].
     Map<FieldEntity, ConstantValue> fields = /*<FieldElement, ConstantValue>*/ {
       field: argument
     };
     return new ConstructedConstantValue(type, fields);
   }
 }
 
@@ skipping 32 matching lines @@
       result.add(keyList);
     } else {
       // Add the keys individually to avoid generating an unused list constant
       // for the keys.
       result.addAll(keys);
     }
     result.addAll(values);
     return result;
   }
 }