Move remaining helpers to BackendHelpers

pkg/compiler/lib/src/cps_ir/cps_ir_builder_task.dart

 // Copyright (c) 2013, 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 dart2js.ir_builder_task;
 
 import '../closure.dart' as closurelib;
 import '../closure.dart' hide ClosureScope;
 import '../common.dart';
 import '../common/names.dart' show
     Names,
     Selectors;
 import '../common/tasks.dart' show
     CompilerTask;
 import '../compiler.dart' show
     Compiler;
 import '../constants/expressions.dart';
 import '../dart_types.dart';
 import '../elements/elements.dart';
 import '../elements/modelx.dart' show
     SynthesizedConstructorElementX,
     ConstructorBodyElementX,
     FunctionSignatureX;
 import '../io/source_information.dart';
+import '../js_backend/backend_helpers.dart' show
+    BackendHelpers;
 import '../js_backend/js_backend.dart' show
     JavaScriptBackend,
     SyntheticConstantKind;
 import '../resolution/tree_elements.dart' show
     TreeElements;
 import '../resolution/semantic_visitor.dart';
 import '../resolution/send_resolver.dart' show
     SendResolverMixin;
 import '../resolution/operators.dart' as op;
 import '../tree/tree.dart' as ast;
@@ skipping 2493 matching lines @@
   ///
   /// Will be initialized upon entering the body of a function.
   /// It is computed by the [ClosureTranslator].
   ClosureClassMap closureClassMap;
 
   JsIrBuilderVisitor(TreeElements elements,
                      Compiler compiler,
                      SourceInformationBuilder sourceInformationBuilder)
       : super(elements, compiler, sourceInformationBuilder);
 
+  BackendHelpers get helpers => backend.helpers;
 
   /// Builds the IR for creating an instance of the closure class corresponding
   /// to the given nested function.
   ClosureClassElement makeSubFunction(ast.FunctionExpression node) {
     ClosureClassMap innerMap =
         compiler.closureToClassMapper.getMappingForNestedFunction(node);
     ClosureClassElement closureClass = innerMap.closureClassElement;
     return closureClass;
   }
 
@@ skipping 816 matching lines @@
           internalError(argument, 'Additional argument.');
         }
       }
       if (count < minimum) {
         internalError(node, 'Expected at least $minimum arguments.');
       }
     }
 
     /// Call a helper method from the isolate library. The isolate library uses
     /// its own isolate structure, that encapsulates dart2js's isolate.
-    ir.Primitive buildIsolateHelperInvocation(String helperName,
+    ir.Primitive buildIsolateHelperInvocation(Element element,
                                               CallStructure callStructure) {
-      Element element = backend.isolateHelperLibrary.find(helperName);
       if (element == null) {
         reporter.internalError(node,
             'Isolate library and compiler mismatch.');
       }
       List<ir.Primitive> arguments = translateStaticArguments(argumentList,
           element, callStructure);
       return irBuilder.buildStaticFunctionInvocation(element,
           callStructure, arguments,
           sourceInformation:
                 sourceInformationBuilder.buildCall(node, node.selector));
@@ skipping 61 matching lines @@
 
       case 'JS_BUILTIN':
         // The first argument is a description of the type and effect of the
         // builtin, which has already been analyzed in the frontend.  The second
         // argument must be a [JsBuiltin] value.  All other arguments are
         // values used by the JavaScript template that is associated with the
         // builtin.
         validateArgumentCount(minimum: 2);
 
         ast.Node builtin = argumentNodes.tail.head;
-        JsBuiltin value = getEnumValue(builtin, backend.jsBuiltinEnum,
+        JsBuiltin value = getEnumValue(builtin, helpers.jsBuiltinEnum,
                                        JsBuiltin.values);
         js.Template template = backend.emitter.builtinTemplateFor(value);
         List<ir.Primitive> arguments =
             argumentNodes.skip(2).mapToList(visit, growable: false);
         return irBuilder.buildForeignCode(template, arguments, behavior);
 
       case 'JS_EMBEDDED_GLOBAL':
         validateArgumentCount(exactly: 2);
 
         String name = expectStringConstant(argumentNodes.tail.head);
@@ skipping 17 matching lines @@
         }
         break;
 
       case 'JS_EFFECT':
         return irBuilder.buildNullConstant();
 
       case 'JS_GET_NAME':
         validateArgumentCount(exactly: 1);
 
         ast.Node argument = argumentNodes.head;
-        JsGetName id = getEnumValue(argument, backend.jsGetNameEnum,
+        JsGetName id = getEnumValue(argument, helpers.jsGetNameEnum,
             JsGetName.values);
         js.Name name = backend.namer.getNameForJsGetName(argument, id);
         ConstantValue nameConstant =
             new SyntheticConstantValue(SyntheticConstantKind.NAME,
                                        js.js.quoteName(name));
 
         return irBuilder.buildConstant(nameConstant);
 
       case 'JS_GET_FLAG':
         validateArgumentCount(exactly: 1);
@@ skipping 18 matching lines @@
         return irBuilder.buildStringConcatenation(arguments);
 
       case 'JS_CURRENT_ISOLATE_CONTEXT':
         validateArgumentCount(exactly: 0);
 
         if (!compiler.hasIsolateSupport) {
           // If the isolate library is not used, we just generate code
           // to fetch the current isolate.
           continue getStaticState;
         }
-        return buildIsolateHelperInvocation('_currentIsolate',
+        return buildIsolateHelperInvocation(backend.helpers.currentIsolate,
             CallStructure.NO_ARGS);
 
       getStaticState: case 'JS_GET_STATIC_STATE':
         validateArgumentCount(exactly: 0);
 
         return irBuilder.buildForeignCode(
             js.js.parseForeignJS(backend.namer.staticStateHolder),
             const <ir.Primitive>[],
             NativeBehavior.PURE);
 
       case 'JS_SET_STATIC_STATE':
         validateArgumentCount(exactly: 1);
 
         ir.Primitive value = visit(argumentNodes.single);
         String isolateName = backend.namer.staticStateHolder;
         return irBuilder.buildForeignCode(
             js.js.parseForeignJS("$isolateName = #"),
             <ir.Primitive>[value],
             NativeBehavior.PURE);
 
       case 'JS_CALL_IN_ISOLATE':
         validateArgumentCount(exactly: 2);
 
         if (!compiler.hasIsolateSupport) {
           ir.Primitive closure = visit(argumentNodes.tail.head);
           return irBuilder.buildCallInvocation(closure, CallStructure.NO_ARGS,
               const <ir.Primitive>[]);
         }
-        return buildIsolateHelperInvocation('_callInIsolate',
+        return buildIsolateHelperInvocation(backend.helpers.callInIsolate,
             CallStructure.TWO_ARGS);
 
       default:
         giveup(node, 'unplemented native construct: ${function.name}');
         break;
     }
   }
 
   @override
   ir.Primitive handleStaticFunctionInvoke(ast.Send node,
                                           MethodElement function,
                                           ast.NodeList argumentList,
                                           CallStructure callStructure,
                                           _) {
     if (compiler.backend.isForeign(function)) {
       return handleForeignCode(node, function, argumentList, callStructure);
     } else {
       return irBuilder.buildStaticFunctionInvocation(function, callStructure,
           translateStaticArguments(argumentList, function, callStructure),
           sourceInformation:
               sourceInformationBuilder.buildCall(node, node.selector));
     }
   }
 }