Move remaining helpers to BackendHelpers

pkg/compiler/lib/src/js_emitter/interceptor_stub_generator.dart

Index: pkg/compiler/lib/src/js_emitter/interceptor_stub_generator.dart
diff --git a/pkg/compiler/lib/src/js_emitter/interceptor_stub_generator.dart b/pkg/compiler/lib/src/js_emitter/interceptor_stub_generator.dart
index 520768557a5dc79dd0a3c9cfc3080eb8c6c5ccd6..2eabee093631d2fcf74a6d1e7a3a4329a1800287 100644
--- a/pkg/compiler/lib/src/js_emitter/interceptor_stub_generator.dart
+++ b/pkg/compiler/lib/src/js_emitter/interceptor_stub_generator.dart
@@ -13,6 +13,8 @@ class InterceptorStubGenerator {
 
   Emitter get emitter => backend.emitter.emitter;
 
+  BackendHelpers get helpers => backend.helpers;
+
   jsAst.Expression generateGetInterceptorMethod(Set<ClassElement> classes) {
     jsAst.Expression interceptorFor(ClassElement cls) {
       return backend.emitter.interceptorPrototypeAccess(cls);
@@ -25,20 +27,20 @@ class InterceptorStubGenerator {
     jsAst.Statement buildInterceptorCheck(ClassElement cls) {
       jsAst.Expression condition;
       assert(backend.isInterceptorClass(cls));
-      if (cls == backend.jsBoolClass) {
+      if (cls == helpers.jsBoolClass) {
         condition = js('(typeof receiver) == "boolean"');
-      } else if (cls == backend.jsIntClass ||
-                 cls == backend.jsDoubleClass ||
-                 cls == backend.jsNumberClass) {
+      } else if (cls == helpers.jsIntClass ||
+                 cls == helpers.jsDoubleClass ||
+                 cls == helpers.jsNumberClass) {
         throw 'internal error';
-      } else if (cls == backend.jsArrayClass ||
-                 cls == backend.jsMutableArrayClass ||
-                 cls == backend.jsFixedArrayClass ||
-                 cls == backend.jsExtendableArrayClass) {
+      } else if (cls == helpers.jsArrayClass ||
+                 cls == helpers.jsMutableArrayClass ||
+                 cls == helpers.jsFixedArrayClass ||
+                 cls == helpers.jsExtendableArrayClass) {
         condition = js('receiver.constructor == Array');
-      } else if (cls == backend.jsStringClass) {
+      } else if (cls == helpers.jsStringClass) {
         condition = js('(typeof receiver) == "string"');
-      } else if (cls == backend.jsNullClass) {
+      } else if (cls == helpers.jsNullClass) {
         condition = js('receiver == null');
       } else {
         throw 'internal error';
@@ -58,16 +60,16 @@ class InterceptorStubGenerator {
           .hasInstantiatedNativeClasses();
 
     for (ClassElement cls in classes) {
-      if (cls == backend.jsArrayClass ||
-          cls == backend.jsMutableArrayClass ||
-          cls == backend.jsFixedArrayClass ||
-          cls == backend.jsExtendableArrayClass) hasArray = true;
-      else if (cls == backend.jsBoolClass) hasBool = true;
-      else if (cls == backend.jsDoubleClass) hasDouble = true;
-      else if (cls == backend.jsIntClass) hasInt = true;
-      else if (cls == backend.jsNullClass) hasNull = true;
-      else if (cls == backend.jsNumberClass) hasNumber = true;
-      else if (cls == backend.jsStringClass) hasString = true;
+      if (cls == helpers.jsArrayClass ||
+          cls == helpers.jsMutableArrayClass ||
+          cls == helpers.jsFixedArrayClass ||
+          cls == helpers.jsExtendableArrayClass) hasArray = true;
+      else if (cls == helpers.jsBoolClass) hasBool = true;
+      else if (cls == helpers.jsDoubleClass) hasDouble = true;
+      else if (cls == helpers.jsIntClass) hasInt = true;
+      else if (cls == helpers.jsNullClass) hasNull = true;
+      else if (cls == helpers.jsNumberClass) hasNumber = true;
+      else if (cls == helpers.jsStringClass) hasString = true;
       else {
         // The set of classes includes classes mixed-in to interceptor classes
         // and user extensions of native classes.
@@ -103,13 +105,13 @@ class InterceptorStubGenerator {
       /// is the fallback used when we have determined that receiver
       /// is a JavaScript Number.
       jsAst.Expression interceptorForNumber = interceptorFor(
-          hasDouble ? backend.jsDoubleClass : backend.jsNumberClass);
+          hasDouble ? helpers.jsDoubleClass : helpers.jsNumberClass);
 
       if (hasInt) {
         whenNumber = js.statement('''{
             if (Math.floor(receiver) == receiver) return #;
             return #;
-        }''', [interceptorFor(backend.jsIntClass), interceptorForNumber]);
+        }''', [interceptorFor(helpers.jsIntClass), interceptorForNumber]);
       } else {
         whenNumber = js.statement('return #', interceptorForNumber);
       }
@@ -118,10 +120,10 @@ class InterceptorStubGenerator {
     }
 
     if (hasString) {
-      statements.add(buildInterceptorCheck(backend.jsStringClass));
+      statements.add(buildInterceptorCheck(helpers.jsStringClass));
     }
     if (hasNull) {
-      statements.add(buildInterceptorCheck(backend.jsNullClass));
+      statements.add(buildInterceptorCheck(helpers.jsNullClass));
     } else {
       // Returning "undefined" or "null" here will provoke a JavaScript
       // TypeError which is later identified as a null-error by
@@ -130,12 +132,12 @@ class InterceptorStubGenerator {
           js.statement('if (receiver == null) return receiver'));
     }
     if (hasBool) {
-      statements.add(buildInterceptorCheck(backend.jsBoolClass));
+      statements.add(buildInterceptorCheck(helpers.jsBoolClass));
     }
     // TODO(ahe): It might be faster to check for Array before
     // function and bool.
     if (hasArray) {
-      statements.add(buildInterceptorCheck(backend.jsArrayClass));
+      statements.add(buildInterceptorCheck(helpers.jsArrayClass));
     }
 
     if (hasNative) {
@@ -147,13 +149,13 @@ class InterceptorStubGenerator {
           if (receiver instanceof #) return receiver;
           return #(receiver);
       }''', [
-          interceptorFor(backend.jsJavaScriptFunctionClass),
+          interceptorFor(helpers.jsJavaScriptFunctionClass),
           backend.emitter.constructorAccess(compiler.coreClasses.objectClass),
           backend.emitter
-              .staticFunctionAccess(backend.getNativeInterceptorMethod)]));
+              .staticFunctionAccess(helpers.getNativeInterceptorMethod)]));
 
     } else {
-      ClassElement jsUnknown = backend.jsUnknownJavaScriptObjectClass;
+      ClassElement jsUnknown = helpers.jsUnknownJavaScriptObjectClass;
       if (compiler.codegenWorld
               .directlyInstantiatedClasses.contains(jsUnknown)) {
         statements.add(
@@ -184,9 +186,9 @@ class InterceptorStubGenerator {
             return a0 != null && receiver === a0;
         }''');
       }
-      if (!classes.contains(backend.jsIntClass)
-          && !classes.contains(backend.jsNumberClass)
-          && !classes.contains(backend.jsDoubleClass)) {
+      if (!classes.contains(helpers.jsIntClass)
+          && !classes.contains(helpers.jsNumberClass)
+          && !classes.contains(helpers.jsDoubleClass)) {
         return null;
       }
       if (selector.argumentCount == 1) {
@@ -228,12 +230,12 @@ class InterceptorStubGenerator {
       //        return receiver[a0] = a1;
       //      }
       //    }
-      bool containsArray = classes.contains(backend.jsArrayClass);
-      bool containsString = classes.contains(backend.jsStringClass);
+      bool containsArray = classes.contains(helpers.jsArrayClass);
+      bool containsString = classes.contains(helpers.jsStringClass);
       bool containsJsIndexable =
-          backend.jsIndexingBehaviorInterface.isResolved && classes.any((cls) {
+          helpers.jsIndexingBehaviorInterface.isResolved && classes.any((cls) {
         return compiler.world.isSubtypeOf(cls,
-            backend.jsIndexingBehaviorInterface);
+            helpers.jsIndexingBehaviorInterface);
       });
       // The index set operator requires a check on its set value in
       // checked mode, so we don't optimize the interceptor if the
@@ -310,7 +312,7 @@ class InterceptorStubGenerator {
     }
 
     jsAst.Name invocationName = backend.namer.invocationName(selector);
-    String globalObject = namer.globalObjectFor(backend.interceptorsLibrary);
+    String globalObject = namer.globalObjectFor(helpers.interceptorsLibrary);
 
     jsAst.Statement optimizedPath =
         _fastPathForOneShotInterceptor(selector, classes);