Remove BackendClasses and JavaScriptBackendClasses.

pkg/compiler/lib/src/js_backend/backend.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 js_backend.backend;
 
 import 'package:js_runtime/shared/embedded_names.dart' as embeddedNames;
 
 import '../common.dart';
 import '../common/backend_api.dart'
-    show BackendClasses, ForeignResolver, NativeRegistry, ImpactTransformer;
+    show ForeignResolver, NativeRegistry, ImpactTransformer;
 import '../common/codegen.dart' show CodegenImpact, CodegenWorkItem;
 import '../common/names.dart' show Uris;
 import '../common/resolution.dart'
     show Frontend, Resolution, ResolutionImpact, Target;
 import '../common/tasks.dart' show CompilerTask;
 import '../compiler.dart' show Compiler;
 import '../constants/constant_system.dart';
 import '../constants/expressions.dart';
 import '../constants/values.dart';
-import '../common_elements.dart' show CommonElements, ElementEnvironment;
+import '../common_elements.dart' show CommonElements;
 import '../deferred_load.dart' show DeferredLoadTask;
 import '../dump_info.dart' show DumpInfoTask;
 import '../elements/elements.dart';
 import '../elements/entities.dart';
 import '../elements/resolution_types.dart';
 import '../elements/types.dart';
 import '../enqueue.dart'
     show
         DirectEnqueuerStrategy,
         Enqueuer,
@@ skipping 411 matching lines @@
   MirrorsDataImpl _mirrorsData;
   CheckedModeHelpers _checkedModeHelpers;
 
   final SuperMemberData superMemberData = new SuperMemberData();
 
   native.NativeResolutionEnqueuer _nativeResolutionEnqueuer;
   native.NativeCodegenEnqueuer _nativeCodegenEnqueuer;
 
   BackendImpacts impacts;
 
-  /// Common classes used by the backend.
-  BackendClasses _backendClasses;
-
   /// Backend access to the front-end.
   final JSFrontendAccess frontend;
 
   Target _target;
 
   Tracer tracer;
 
   static SourceInformationStrategy createSourceInformationStrategy(
       {bool generateSourceMap: false,
       bool useMultiSourceInfo: false,
@@ skipping 82 matching lines @@
 
   /// Codegen support for generating table of interceptors and
   /// constructors for custom elements.
   CustomElementsCodegenAnalysis get customElementsCodegenAnalysis {
     assert(invariant(
         NO_LOCATION_SPANNABLE, _customElementsCodegenAnalysis != null,
         message: "CustomElementsCodegenAnalysis has not been created yet."));
     return _customElementsCodegenAnalysis;
   }
 
-  /// Common classes used by the backend.
-  BackendClasses get backendClasses {
-    assert(invariant(NO_LOCATION_SPANNABLE, _backendClasses != null,
-        message: "BackendClasses has not been created yet."));
-    return _backendClasses;
-  }
-
   NativeBasicData get nativeBasicData {
     assert(invariant(NO_LOCATION_SPANNABLE, _nativeBasicData != null,
         message: "NativeBasicData has not been computed yet."));
     return _nativeBasicData;
   }
 
   NativeBasicDataBuilder get nativeBasicDataBuilder => _nativeBasicDataBuilder;
 
   /// Resolution analysis for tracking reflective access to type variables.
   TypeVariableResolutionAnalysis get typeVariableResolutionAnalysis {
@@ skipping 262 matching lines @@
           node, MessageKind.WRONG_ARGUMENT_FOR_JS_INTERCEPTOR_CONSTANT);
     }
     // No native behavior for this call.
     return null;
   }
 
   ResolutionEnqueuer createResolutionEnqueuer(
       CompilerTask task, Compiler compiler) {
     _nativeBasicData =
         nativeBasicDataBuilder.close(compiler.elementEnvironment);
-    _backendClasses = new JavaScriptBackendClasses(
-        compiler.elementEnvironment, commonElements, nativeBasicData);
     _nativeResolutionEnqueuer = new native.NativeResolutionEnqueuer(
         compiler.options,
         compiler.elementEnvironment,
         commonElements,
-        backendClasses,
         backendUsageBuilder,
         new NativeClassResolverImpl(
             compiler.resolution, reporter, commonElements, nativeBasicData));
     _nativeData = new NativeDataImpl(nativeBasicData);
     _customElementsResolutionAnalysis = new CustomElementsResolutionAnalysis(
         compiler.resolution,
         constantSystem,
         commonElements,
-        backendClasses,
         nativeBasicData,
         backendUsageBuilder);
     impactTransformer = new JavaScriptImpactTransformer(
         compiler.options,
         compiler.elementEnvironment,
         commonElements,
         impacts,
         nativeBasicData,
         _nativeResolutionEnqueuer,
         backendUsageBuilder,
         mirrorsDataBuilder,
         customElementsResolutionAnalysis,
         rtiNeedBuilder);
     _interceptorDataBuilder = new InterceptorDataBuilderImpl(
         nativeBasicData, compiler.elementEnvironment, commonElements);
     return new ResolutionEnqueuer(
         task,
         compiler.options,
         compiler.reporter,
         compiler.options.analyzeOnly && compiler.options.analyzeMain
             ? const DirectEnqueuerStrategy()
             : const TreeShakingEnqueuerStrategy(),
         new ResolutionEnqueuerListener(
             compiler.options,
             compiler.elementEnvironment,
             commonElements,
             impacts,
-            backendClasses,
             nativeBasicData,
             interceptorDataBuilder,
             backendUsageBuilder,
             rtiNeedBuilder,
             mirrorsDataBuilder,
             noSuchMethodRegistry,
             customElementsResolutionAnalysis,
             lookupMapResolutionAnalysis,
             mirrorsResolutionAnalysis,
             typeVariableResolutionAnalysis,
             _nativeResolutionEnqueuer,
             compiler.deferredLoadTask,
             kernelTask),
         new ElementResolutionWorldBuilder(
             this, compiler.resolution, const OpenWorldStrategy()),
         new ResolutionWorkItemBuilder(compiler.resolution));
   }
 
   /// Creates an [Enqueuer] for code generation specific to this backend.
   CodegenEnqueuer createCodegenEnqueuer(
       CompilerTask task, Compiler compiler, ClosedWorld closedWorld) {
     _typeVariableCodegenAnalysis = new TypeVariableCodegenAnalysis(
         compiler.elementEnvironment, this, commonElements, mirrorsData);
     _lookupMapAnalysis = new LookupMapAnalysis(
         reporter,
         constantSystem,
         constants,
         compiler.elementEnvironment,
         commonElements,
-        backendClasses,
         lookupMapResolutionAnalysis);
     _mirrorsCodegenAnalysis = mirrorsResolutionAnalysis.close();
     _customElementsCodegenAnalysis = new CustomElementsCodegenAnalysis(
-        compiler.resolution,
-        constantSystem,
-        commonElements,
-        backendClasses,
-        nativeBasicData);
+        compiler.resolution, constantSystem, commonElements, nativeBasicData);
     _nativeCodegenEnqueuer = new native.NativeCodegenEnqueuer(
         compiler.options,
         compiler.elementEnvironment,
         commonElements,
-        backendClasses,
         emitter,
         _nativeResolutionEnqueuer,
         nativeData);
     return new CodegenEnqueuer(
         task,
         compiler.options,
         const TreeShakingEnqueuerStrategy(),
         new CodegenWorldBuilderImpl(
             nativeBasicData, closedWorld, constants, const TypeMaskStrategy()),
         new CodegenWorkItemBuilder(this, compiler.options),
         new CodegenEnqueuerListener(
             compiler.elementEnvironment,
             commonElements,
             impacts,
-            backendClasses,
             backendUsage,
             rtiNeed,
             customElementsCodegenAnalysis,
             typeVariableCodegenAnalysis,
             lookupMapAnalysis,
             mirrorsCodegenAnalysis,
             nativeCodegenEnqueuer));
   }
 
   WorldImpact codegen(CodegenWorkItem work) {
@@ skipping 507 matching lines @@
   @override
   void onImpactUsed(ImpactUseCase impactUse) {
     if (impactUse == DeferredLoadTask.IMPACT_USE && !supportSerialization) {
       // TODO(johnniwinther): Allow emptying when serialization has been
       // performed.
       resolution.emptyCache();
     }
   }
 }
 
-// TODO(efortuna): Merge with commonElements.
-class JavaScriptBackendClasses implements BackendClasses {
-  final ElementEnvironment _env;
-  final CommonElements _commonElements;
-  final NativeBasicData _nativeData;
-
-  JavaScriptBackendClasses(this._env, this._commonElements, this._nativeData);
-
-  ClassEntity get intClass => _commonElements.jsIntClass;
-  ClassEntity get uint32Class => _commonElements.jsUInt32Class;
-  ClassEntity get uint31Class => _commonElements.jsUInt31Class;
-  ClassEntity get positiveIntClass => _commonElements.jsPositiveIntClass;
-  ClassEntity get doubleClass => _commonElements.jsDoubleClass;
-  ClassEntity get numClass => _commonElements.jsNumberClass;
-  ClassEntity get stringClass => _commonElements.jsStringClass;
-  ClassEntity get listClass => _commonElements.jsArrayClass;
-  ClassEntity get mutableListClass => _commonElements.jsMutableArrayClass;
-  ClassEntity get constListClass => _commonElements.jsUnmodifiableArrayClass;
-  ClassEntity get fixedListClass => _commonElements.jsFixedArrayClass;
-  ClassEntity get growableListClass => _commonElements.jsExtendableArrayClass;
-  ClassEntity get mapClass => _commonElements.mapLiteralClass;
-  ClassEntity get constMapClass => _commonElements.constMapLiteralClass;
-  ClassEntity get typeClass => _commonElements.typeLiteralClass;
-  InterfaceType get typeType => _env.getRawType(typeClass);
-
-  ClassEntity get boolClass => _commonElements.jsBoolClass;
-  ClassEntity get nullClass => _commonElements.jsNullClass;
-  ClassEntity get syncStarIterableClass => _commonElements.syncStarIterable;
-  ClassEntity get asyncFutureClass => _commonElements.futureImplementation;
-  ClassEntity get asyncStarStreamClass => _commonElements.controllerStream;
-  ClassEntity get functionClass => _commonElements.functionClass;
-  ClassEntity get indexableClass => _commonElements.jsIndexableClass;
-  ClassEntity get mutableIndexableClass =>
-      _commonElements.jsMutableIndexableClass;
-  ClassEntity get indexingBehaviorClass =>
-      _commonElements.jsIndexingBehaviorInterface;
-  ClassEntity get interceptorClass => _commonElements.jsInterceptorClass;
-
-  bool isDefaultEqualityImplementation(MemberEntity element) {
-    assert(element.name == '==');
-    ClassEntity classElement = element.enclosingClass;
-    return classElement == _commonElements.objectClass ||
-        classElement == _commonElements.jsInterceptorClass ||
-        classElement == _commonElements.jsNullClass;
-  }
-
-  @override
-  bool isNativeClass(ClassEntity element) {
-    return _nativeData.isNativeClass(element);
-  }
-
-  InterfaceType getConstantMapTypeFor(InterfaceType sourceType,
-      {bool hasProtoKey: false, bool onlyStringKeys: false}) {
-    ClassEntity classElement = onlyStringKeys
-        ? (hasProtoKey
-            ? _commonElements.constantProtoMapClass
-            : _commonElements.constantStringMapClass)
-        : _commonElements.generalConstantMapClass;
-    List<DartType> typeArgument = sourceType.typeArguments;
-    if (sourceType.treatAsRaw) {
-      return _env.getRawType(classElement);
-    } else {
-      return _env.createInterfaceType(classElement, typeArgument);
-    }
-  }
-
-  @override
-  FieldEntity get symbolField => _commonElements.symbolImplementationField;
-
-  @override
-  InterfaceType get symbolType {
-    return _env.getRawType(_commonElements.symbolImplementationClass);
-  }
-}
-
 class JavaScriptBackendTarget extends Target {
   final JavaScriptBackend _backend;
 
   JavaScriptBackendTarget(this._backend);
 
   @override
   bool isTargetSpecificLibrary(LibraryElement element) {
     return _backend.isTargetSpecificLibrary(element);
   }
 
@@ skipping 48 matching lines @@
 
   bool canUseAliasedSuperMember(MemberEntity member, Selector selector) {
     return !selector.isGetter;
   }
 
   /// Returns `true` if [member] is called from a subclass via `super`.
   bool isAliasedSuperMember(MemberEntity member) {
     return _aliasedSuperMembers.contains(member);
   }
 }