Remove BackendClasses and JavaScriptBackendClasses.

pkg/compiler/lib/src/native/behavior.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.
 
 import '../common.dart';
-import '../common/backend_api.dart' show BackendClasses, ForeignResolver;
+import '../common/backend_api.dart' show ForeignResolver;
 import '../common/resolution.dart' show ParsingContext, Resolution;
 import '../compiler.dart' show Compiler;
 import '../compile_time_constants.dart' show ConstantEnvironment;
 import '../constants/expressions.dart';
 import '../constants/values.dart';
 import '../common_elements.dart' show CommonElements;
 import '../elements/elements.dart';
 import '../elements/entities.dart';
 import '../elements/resolution_types.dart';
 import '../elements/types.dart';
 import '../js/js.dart' as js;
+import '../js_backend/native_data.dart' show NativeData;
 import '../tree/tree.dart';
 import '../universe/side_effects.dart' show SideEffects;
 import '../util/util.dart';
 import 'js.dart';
 
 typedef dynamic /*DartType|SpecialType*/ TypeLookup(String typeString,
     {bool required});
 
 /// This class is a temporary work-around until we get a more powerful DartType.
 class SpecialType {
@@ skipping 740 matching lines @@
   static NativeBehavior ofMethodElement(
       MethodElement element, Compiler compiler,
       {bool isJsInterop}) {
     ResolutionFunctionType type = element.computeType(compiler.resolution);
     List<ConstantExpression> metadata = <ConstantExpression>[];
     for (MetadataAnnotation annotation in element.implementation.metadata) {
       annotation.ensureResolved(compiler.resolution);
       metadata.add(annotation.constant);
     }
 
-    BehaviorBuilder builder = new ResolverBehaviorBuilder(compiler);
+    BehaviorBuilder builder =
+        new ResolverBehaviorBuilder(compiler, compiler.backend.nativeData);
     return builder.buildMethodBehavior(
         type, metadata, lookupFromElement(compiler.resolution, element),
         isJsInterop: isJsInterop);
   }
 
   static NativeBehavior ofFieldElementLoad(
       MemberElement element, Compiler compiler,
       {bool isJsInterop}) {
     Resolution resolution = compiler.resolution;
     ResolutionDartType type = element.computeType(resolution);
     List<ConstantExpression> metadata = <ConstantExpression>[];
     for (MetadataAnnotation annotation in element.implementation.metadata) {
       annotation.ensureResolved(compiler.resolution);
       metadata.add(annotation.constant);
     }
 
-    BehaviorBuilder builder = new ResolverBehaviorBuilder(compiler);
+    BehaviorBuilder builder =
+        new ResolverBehaviorBuilder(compiler, compiler.backend.nativeData);
     return builder.buildFieldLoadBehavior(
         type, metadata, lookupFromElement(resolution, element),
         isJsInterop: isJsInterop);
   }
 
   static NativeBehavior ofFieldElementStore(
       MemberElement field, Compiler compiler) {
-    BehaviorBuilder builder = new ResolverBehaviorBuilder(compiler);
+    BehaviorBuilder builder =
+        new ResolverBehaviorBuilder(compiler, compiler.backend.nativeData);
     ResolutionDartType type = field.computeType(compiler.resolution);
     return builder.buildFieldStoreBehavior(type);
   }
 
   static TypeLookup lookupFromElement(Resolution resolution, Element element) {
     ResolutionDartType lookup(String name, {bool required}) {
       Element e = element.buildScope().lookup(name);
       if (e == null || e is! ClassElement) {
         if (required) {
           resolution.reporter.reportErrorMessage(element, MessageKind.GENERIC,
@@ skipping 25 matching lines @@
         // TODO(sra): Parse type parameters.
         return type;
       }
     }
     return const ResolutionDynamicType();
   }
 }
 
 abstract class BehaviorBuilder {
   CommonElements get commonElements;
-  BackendClasses get backendClasses;
   DiagnosticReporter get reporter;
   ConstantEnvironment get constants;
+  NativeData get nativeData;
   bool get trustJSInteropTypeAnnotations;
 
   Resolution get resolution => null;
 
   NativeBehavior _behavior;
 
   void _overrideWithAnnotations(
       Iterable<ConstantExpression> metadata, TypeLookup lookupType) {
     if (metadata.isEmpty) return;
 
@@ skipping 77 matching lines @@
     if (type is FunctionType) {
       FunctionType functionType = type;
       _capture(functionType.returnType, isInterop: isInterop);
       for (DartType parameter in functionType.parameterTypes) {
         _escape(parameter);
       }
     } else {
       if (!isInterop) {
         _behavior.typesInstantiated.add(type);
       } else {
-        if (type is InterfaceType &&
-            backendClasses.isNativeClass(type.element)) {
+        if (type is InterfaceType && nativeData.isNativeClass(type.element)) {
           // Any declared native or interop type (isNative implies isJsInterop)
           // is assumed to be allocated.
           _behavior.typesInstantiated.add(type);
         }
 
         if (!trustJSInteropTypeAnnotations ||
             type.isDynamic ||
             type == commonElements.objectType) {
           // By saying that only JS-interop types can be created, we prevent
           // pulling in every other native type (e.g. all of dart:html) when a
@@ skipping 67 matching lines @@
       _escape(type);
     }
 
     _overrideWithAnnotations(metadata, lookupType);
     return _behavior;
   }
 }
 
 class ResolverBehaviorBuilder extends BehaviorBuilder {
   final Compiler compiler;
+  final NativeData nativeData;
 
-  ResolverBehaviorBuilder(this.compiler);
+  ResolverBehaviorBuilder(this.compiler, this.nativeData);
 
   @override
   CommonElements get commonElements => compiler.commonElements;
 
   @override
   bool get trustJSInteropTypeAnnotations =>
       compiler.options.trustJSInteropTypeAnnotations;
 
   @override
   ConstantEnvironment get constants => compiler.constants;
 
   @override
   DiagnosticReporter get reporter => compiler.reporter;
 
   @override
-  BackendClasses get backendClasses => compiler.backend.backendClasses;
-
-  @override
   Resolution get resolution => compiler.resolution;
 }