Remove BackendClasses and JavaScriptBackendClasses.

pkg/compiler/lib/src/common_elements.dart

 // Copyright (c) 2014, 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.
 
 // TODO(sigmund): rename and move to common/elements.dart
 library dart2js.type_system;
 
 import 'common/names.dart' show Identifiers, Uris;
 import 'js_backend/constant_system_javascript.dart';
 import 'elements/types.dart';
@@ skipping 244 matching lines @@
 
   /// The `Function` type defined in 'dart:core'.
   InterfaceType get functionType => _getRawType(functionClass);
 
   /// The `Null` type defined in 'dart:core'.
   InterfaceType get nullType => _getRawType(nullClass);
 
   /// The `Type` type defined in 'dart:core'.
   InterfaceType get typeType => _getRawType(typeClass);
 
+  InterfaceType get typeLiteralType => _getRawType(typeLiteralClass);
+
   /// The `StackTrace` type defined in 'dart:core';
   InterfaceType get stackTraceType => _getRawType(stackTraceClass);
 
   /// Returns an instance of the `List` type defined in 'dart:core' with
   /// [elementType] as its type argument.
   ///
   /// If no type argument is provided, the canonical raw type is returned.
   InterfaceType listType([DartType elementType]) {
     if (elementType == null) {
       return _getRawType(listClass);
@@ skipping 94 matching lines @@
   InterfaceType _getRawType(ClassEntity cls) {
     return _env.getRawType(cls);
   }
 
   /// Create the instantiation of [cls] with the given [typeArguments].
   InterfaceType _createInterfaceType(
       ClassEntity cls, List<DartType> typeArguments) {
     return _env.createInterfaceType(cls, typeArguments);
   }
 
+  InterfaceType getConstantMapTypeFor(InterfaceType sourceType,
+      {bool hasProtoKey: false, bool onlyStringKeys: false}) {
+    ClassEntity classElement = onlyStringKeys
+        ? (hasProtoKey ? constantProtoMapClass : constantStringMapClass)
+        : generalConstantMapClass;
+    List<DartType> typeArgument = sourceType.typeArguments;
+    if (sourceType.treatAsRaw) {
+      return _env.getRawType(classElement);
+    } else {
+      return _env.createInterfaceType(classElement, typeArgument);
+    }
+  }
+
+  FieldEntity get symbolField => symbolImplementationField;
+
+  InterfaceType get symbolImplementationType =>
+      _env.getRawType(symbolImplementationClass);
+
+  bool isDefaultEqualityImplementation(MemberEntity element) {
+    assert(element.name == '==');
+    ClassEntity classElement = element.enclosingClass;
+    return classElement == objectClass ||
+        classElement == jsInterceptorClass ||
+        classElement == jsNullClass;
+  }
+
   // From dart:core
   FunctionEntity get malformedTypeError =>
       _cachedCoreHelper('_malformedTypeError');
   FunctionEntity get genericNoSuchMethod =>
       _cachedCoreHelper('_genericNoSuchMethod');
   FunctionEntity get unresolvedConstructorError =>
       _cachedCoreHelper('_unresolvedConstructorError');
   FunctionEntity get unresolvedStaticGetterError =>
       _cachedCoreHelper('_unresolvedStaticGetterError');
   FunctionEntity get unresolvedStaticSetterError =>
@@ skipping 774 matching lines @@
   DartType getUnaliasedType(DartType type);
 
   /// Returns the [CallStructure] corresponding to calling [entity] with all
   /// arguments, both required and optional.
   CallStructure getCallStructure(FunctionEntity entity);
 
   /// Returns `true` if [member] a the synthetic getter `loadLibrary` injected
   /// on deferred libraries.
   bool isDeferredLoadLibraryGetter(MemberEntity member);
 }