Move remaining helpers to BackendHelpers

tests/compiler/dart2js/type_combination_test.dart

Index: tests/compiler/dart2js/type_combination_test.dart
diff --git a/tests/compiler/dart2js/type_combination_test.dart b/tests/compiler/dart2js/type_combination_test.dart
index c07ea86663448348cfaed6d68dc84088df8b9bc5..17af7f41efbacee4eeeb1d4d19f4c792463a4481 100644
--- a/tests/compiler/dart2js/type_combination_test.dart
+++ b/tests/compiler/dart2js/type_combination_test.dart
@@ -4,6 +4,7 @@
 
 import 'package:async_helper/async_helper.dart';
 import 'package:expect/expect.dart';
+import 'package:compiler/src/js_backend/backend_helpers.dart';
 import 'package:compiler/src/js_backend/js_backend.dart';
 import 'package:compiler/src/types/types.dart';
 import 'package:compiler/src/world.dart';
@@ -412,6 +413,7 @@ void testUnion(MockCompiler compiler) {
 
 void testIntersection(MockCompiler compiler) {
   JavaScriptBackend backend = compiler.backend;
+  BackendHelpers helpers = backend.helpers;
   RuleSet ruleSet = new RuleSet('intersection',
       (t1, t2) => t1.intersection(t2, compiler.world));
   rule(type1, type2, result) => ruleSet.rule(type1, type2, result);
@@ -554,9 +556,9 @@ void testIntersection(MockCompiler compiler) {
   rule(jsIndexable, nonPrimitive1, emptyType);
   rule(jsIndexable, nonPrimitive2, emptyType);
   rule(jsIndexable, potentialArray, new TypeMask.nonNullSubtype(
-      backend.jsArrayClass, compiler.world));
+      helpers.jsArrayClass, compiler.world));
   rule(jsIndexable, potentialString, new TypeMask.nonNullSubtype(
-      backend.jsStringClass, compiler.world));
+      helpers.jsStringClass, compiler.world));
   rule(jsIndexable, jsBooleanOrNull, emptyType);
   rule(jsIndexable, jsNumberOrNull, emptyType);
   rule(jsIndexable, jsIntegerOrNull, emptyType);
@@ -731,8 +733,9 @@ void testRegressions(MockCompiler compiler) {
 void main() {
   asyncTest(() => MockCompiler.create((MockCompiler compiler) {
     JavaScriptBackend backend = compiler.backend;
+    BackendHelpers helpers = backend.helpers;
     World world = compiler.world;
-    backend.interceptorsLibrary.forEachLocalMember((element) {
+    helpers.interceptorsLibrary.forEachLocalMember((element) {
       if (element.isClass) {
         element.ensureResolved(compiler.resolution);
         backend.registerInstantiatedType(
@@ -762,39 +765,39 @@ void main() {
     potentialArray = new TypeMask.subtype(
         compiler.coreClasses.listClass, world);
     potentialString = new TypeMask.subtype(patternClass, world);
-    jsInterceptor = new TypeMask.nonNullSubclass(backend.jsInterceptorClass,
+    jsInterceptor = new TypeMask.nonNullSubclass(helpers.jsInterceptorClass,
         world);
-    jsArrayOrNull = new TypeMask.subclass(backend.jsArrayClass, world);
-    jsReadableArray = new TypeMask.nonNullSubclass(backend.jsArrayClass,
+    jsArrayOrNull = new TypeMask.subclass(helpers.jsArrayClass, world);
+    jsReadableArray = new TypeMask.nonNullSubclass(helpers.jsArrayClass,
         world);
-    jsMutableArrayOrNull = new TypeMask.subclass(backend.jsMutableArrayClass,
+    jsMutableArrayOrNull = new TypeMask.subclass(helpers.jsMutableArrayClass,
         world);
-    jsMutableArray = new TypeMask.nonNullSubclass(backend.jsMutableArrayClass,
+    jsMutableArray = new TypeMask.nonNullSubclass(helpers.jsMutableArrayClass,
         world);
-    jsFixedArrayOrNull = new TypeMask.exact(backend.jsFixedArrayClass, world);
-    jsFixedArray = new TypeMask.nonNullExact(backend.jsFixedArrayClass, world);
-    jsExtendableArrayOrNull = new TypeMask.exact(backend.jsExtendableArrayClass,
+    jsFixedArrayOrNull = new TypeMask.exact(helpers.jsFixedArrayClass, world);
+    jsFixedArray = new TypeMask.nonNullExact(helpers.jsFixedArrayClass, world);
+    jsExtendableArrayOrNull = new TypeMask.exact(helpers.jsExtendableArrayClass,
         world);
     jsExtendableArray = new TypeMask.nonNullExact(
-        backend.jsExtendableArrayClass, world);
+        helpers.jsExtendableArrayClass, world);
     jsUnmodifiableArrayOrNull =
-        new TypeMask.exact(backend.jsUnmodifiableArrayClass, world);
+        new TypeMask.exact(helpers.jsUnmodifiableArrayClass, world);
     jsUnmodifiableArray =
-        new TypeMask.nonNullExact(backend.jsUnmodifiableArrayClass, world);
-    jsIndexableOrNull = new TypeMask.subtype(backend.jsIndexableClass, world);
-    jsIndexable = new TypeMask.nonNullSubtype(backend.jsIndexableClass, world);
-    jsInterceptorOrNull = new TypeMask.subclass(backend.jsInterceptorClass,
+        new TypeMask.nonNullExact(helpers.jsUnmodifiableArrayClass, world);
+    jsIndexableOrNull = new TypeMask.subtype(helpers.jsIndexableClass, world);
+    jsIndexable = new TypeMask.nonNullSubtype(helpers.jsIndexableClass, world);
+    jsInterceptorOrNull = new TypeMask.subclass(helpers.jsInterceptorClass,
         world);
-    jsStringOrNull = new TypeMask.exact(backend.jsStringClass, world);
-    jsString = new TypeMask.nonNullExact(backend.jsStringClass, world);
-    jsBoolean = new TypeMask.nonNullExact(backend.jsBoolClass, world);
-    jsNumber = new TypeMask.nonNullSubclass(backend.jsNumberClass, world);
-    jsInteger = new TypeMask.nonNullExact(backend.jsIntClass, world);
-    jsDouble = new TypeMask.nonNullExact(backend.jsDoubleClass, world);
-    jsBooleanOrNull = new TypeMask.exact(backend.jsBoolClass, world);
-    jsNumberOrNull = new TypeMask.subclass(backend.jsNumberClass, world);
-    jsIntegerOrNull = new TypeMask.exact(backend.jsIntClass, world);
-    jsDoubleOrNull = new TypeMask.exact(backend.jsDoubleClass, world);
+    jsStringOrNull = new TypeMask.exact(helpers.jsStringClass, world);
+    jsString = new TypeMask.nonNullExact(helpers.jsStringClass, world);
+    jsBoolean = new TypeMask.nonNullExact(helpers.jsBoolClass, world);
+    jsNumber = new TypeMask.nonNullSubclass(helpers.jsNumberClass, world);
+    jsInteger = new TypeMask.nonNullExact(helpers.jsIntClass, world);
+    jsDouble = new TypeMask.nonNullExact(helpers.jsDoubleClass, world);
+    jsBooleanOrNull = new TypeMask.exact(helpers.jsBoolClass, world);
+    jsNumberOrNull = new TypeMask.subclass(helpers.jsNumberClass, world);
+    jsIntegerOrNull = new TypeMask.exact(helpers.jsIntClass, world);
+    jsDoubleOrNull = new TypeMask.exact(helpers.jsDoubleClass, world);
     nullType = const TypeMask.empty();
     objectType = new TypeMask.nonNullSubclass(
         compiler.coreClasses.objectClass, world);