Introduce BackendImpact to separate enqueueing from data.

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/names.dart' show
     Names,
@@ skipping 485 matching lines @@
           if (labelOrCase is ast.CaseMatch) {
             ir.Primitive constant = translateConstant(labelOrCase.expression);
             caseInfo.addConstant(constant);
           }
         }
       }
     }
     ir.Primitive value = visit(node.expression);
     JumpTarget target = elements.getTargetDefinition(node);
     Element error =
-        (compiler.backend as JavaScriptBackend).getFallThroughError();
+        (compiler.backend as JavaScriptBackend).helpers.fallThroughError;
     irBuilder.buildSimpleSwitch(target, value, cases, defaultCase, error,
         sourceInformationBuilder.buildGeneric(node));
   }
 
   visitTryStatement(ast.TryStatement node) {
     List<CatchClauseInfo> catchClauseInfos = <CatchClauseInfo>[];
     for (ast.CatchBlock catchClause in node.catchBlocks.nodes) {
       LocalVariableElement exceptionVariable;
       if (catchClause.exception != null) {
         exceptionVariable = elements[catchClause.exception];
@@ skipping 1968 matching lines @@
 
   GlobalProgramInformation(this._compiler);
 
   /// Returns [true], if the analysis could not determine that the type
   /// arguments for the class [cls] are never used in the program.
   bool requiresRuntimeTypesFor(ClassElement cls) {
     return cls.typeVariables.isNotEmpty && _backend.classNeedsRti(cls);
   }
 
   FunctionElement get stringifyFunction {
-    return _backend.getStringInterpolationHelper();
+    return _backend.helpers.stringInterpolationHelper;
   }
 
-  FunctionElement get throwTypeErrorHelper => _backend.getThrowTypeError();
+  FunctionElement get throwTypeErrorHelper => _backend.helpers.throwTypeError;
 
   ClassElement get nullClass => _compiler.nullClass;
 
   DartType unaliasType(DartType type) => type.unalias(_compiler.resolution);
 
   TypeMask getTypeMaskForForeign(NativeBehavior behavior) {
     if (behavior == null) {
       return _backend.dynamicType;
     }
     return TypeMaskFactory.fromNativeBehavior(behavior, _compiler);
   }
 
   FieldElement locateSingleField(Selector selector, TypeMask type) {
     return _compiler.world.locateSingleField(selector, type);
   }
 
   Element get closureConverter {
-    return _backend.getClosureConverter();
+    return _backend.helpers.closureConverter;
   }
 
   void addNativeMethod(FunctionElement function) {
     _backend.emitter.nativeEmitter.nativeMethods.add(function);
   }
 }
 
 /// IR builder specific to the JavaScript backend, coupled to the [JsIrBuilder].
 class JsIrBuilderVisitor extends IrBuilderVisitor {
   JavaScriptBackend get backend => compiler.backend;
@@ skipping 754 matching lines @@
         target,
         callStructure,
         constructor.computeEffectiveTargetType(type),
         arguments,
         sourceInformationBuilder.buildNew(node));
   }
 
   @override
   ir.Primitive buildStaticNoSuchMethod(Selector selector,
                                        List<ir.Primitive> arguments) {
-    Element thrower = backend.getThrowNoSuchMethod();
+    Element thrower = backend.helpers.throwNoSuchMethod;
     ir.Primitive receiver = irBuilder.buildStringConstant('');
     ir.Primitive name = irBuilder.buildStringConstant(selector.name);
     ir.Primitive argumentList = irBuilder.buildListLiteral(null, arguments);
     ir.Primitive expectedArgumentNames = irBuilder.buildNullConstant();
     return irBuilder.buildStaticFunctionInvocation(
         thrower,
         new CallStructure.unnamed(4),
         [receiver, name, argumentList, expectedArgumentNames]);
   }
 
   @override
   ir.Primitive buildInstanceNoSuchMethod(Selector selector,
                                          TypeMask mask,
                                          List<ir.Primitive> arguments) {
     return irBuilder.buildDynamicInvocation(
         irBuilder.buildThis(),
         Selectors.noSuchMethod_,
         mask,
         [irBuilder.buildInvocationMirror(selector, arguments)]);
   }
 
   @override
   ir.Primitive buildRuntimeError(String message) {
     return irBuilder.buildStaticFunctionInvocation(
-        backend.getThrowRuntimeError(),
+        backend.helpers.throwRuntimeError,
         new CallStructure.unnamed(1),
         [irBuilder.buildStringConstant(message)]);
   }
 
   @override
   ir.Primitive buildAbstractClassInstantiationError(ClassElement element) {
     return irBuilder.buildStaticFunctionInvocation(
-        backend.getThrowAbstractClassInstantiationError(),
+        backend.helpers.throwAbstractClassInstantiationError,
         new CallStructure.unnamed(1),
         [irBuilder.buildStringConstant(element.name)]);
   }
 
   @override
   ir.Primitive handleStaticFieldGet(ast.Send node, FieldElement field, _) {
     SourceInformation src = sourceInformationBuilder.buildGet(node);
     return buildStaticFieldGet(field, src);
   }
 
@@ skipping 244 matching lines @@
     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));
     }
   }
 }