Merge CommonElements and BackendHelpers!

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/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/js_backend.dart';
-import '../js_backend/backend_helpers.dart';
 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 812 matching lines @@
         return type;
       }
     }
     return const ResolutionDynamicType();
   }
 }
 
 abstract class BehaviorBuilder {
   CommonElements get commonElements;
   BackendClasses get backendClasses;
-  BackendHelpers get helpers;
   DiagnosticReporter get reporter;
   ConstantEnvironment get constants;
   bool get trustJSInteropTypeAnnotations;
 
   Resolution get resolution => null;
 
   NativeBehavior _behavior;
 
   void _overrideWithAnnotations(
       Iterable<ConstantExpression> metadata, TypeLookup lookupType) {
     if (metadata.isEmpty) return;
 
     List creates =
-        _collect(metadata, helpers.annotationCreatesClass, lookupType);
+        _collect(metadata, commonElements.annotationCreatesClass, lookupType);
     List returns =
-        _collect(metadata, helpers.annotationReturnsClass, lookupType);
+        _collect(metadata, commonElements.annotationReturnsClass, lookupType);
 
     if (creates != null) {
       _behavior.typesInstantiated
         ..clear()
         ..addAll(creates);
     }
     if (returns != null) {
       _behavior.typesReturned
         ..clear()
         ..addAll(returns);
@@ skipping 79 matching lines @@
 
         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
           // JS interop API returns dynamic or when we don't trust the type
           // annotations. This means that to some degree we still use the return
           // type to decide whether to include native types, even if we don't
           // trust the type annotation.
-          ClassElement cls = helpers.jsJavaScriptObjectClass;
+          ClassElement cls = commonElements.jsJavaScriptObjectClass;
           cls.ensureResolved(resolution);
           _behavior.typesInstantiated.add(cls.thisType);
         } else {
           // Otherwise, when the declared type is a Dart type, we do not
           // register an allocation because we assume it cannot be instantiated
           // from within the JS-interop code. It must have escaped from another
           // API.
         }
       }
     }
@@ skipping 69 matching lines @@
   bool get trustJSInteropTypeAnnotations =>
       compiler.options.trustJSInteropTypeAnnotations;
 
   @override
   ConstantEnvironment get constants => compiler.constants;
 
   @override
   DiagnosticReporter get reporter => compiler.reporter;
 
   @override
-  BackendHelpers get helpers {
-    JavaScriptBackend backend = compiler.backend;
-    return backend.helpers;
-  }
-
-  @override
   BackendClasses get backendClasses => compiler.backend.backendClasses;
 
   @override
   Resolution get resolution => compiler.resolution;
 }