Stop resolving all of js_helper unconditionally.

sdk/lib/_internal/compiler/implementation/ssa/builder.dart

 // Copyright (c) 2012, 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.
 
 part of ssa;
 
 /**
  * A special element for the extra parameter taken by intercepted
  * methods. We need to override [Element.computeType] because our
  * optimizers may look at its declared type.
@@ skipping 2637 matching lines @@
         stack.add(graph.addConstantBool(true, constantSystem));
         return;
       }
 
       HInstruction instruction;
       if (type.element.isTypeVariable() ||
           RuntimeTypeInformation.hasTypeArguments(type)) {
 
         void argumentsCheck() {
           HInstruction typeInfo = getRuntimeTypeInfo(expression);
-          Element helper =
-              compiler.findHelper(const SourceString('checkArguments'));
+          Element helper = backend.getCheckArguments();
           HInstruction helperCall = new HStatic(helper);
           add(helperCall);
           List<HInstruction> representations =
               buildTypeArgumentRepresentations(type);
           Element element = type.element;
           String substitution = backend.namer.substitutionName(element);
           if (backend.emitter.nativeEmitter.requiresNativeIsCheck(element)) {
             substitution = '$substitution()';
           }
           HInstruction fieldGet =
@@ skipping 392 matching lines @@
     HStatic target = new HStatic(element);
     add(target);
     HInstruction self = localsHandler.readThis();
     Constant nameConstant = constantSystem.createString(
         new DartString.literal(name.slowToString()), node);
 
     String internalName = backend.namer.invocationName(selector);
     Constant internalNameConstant =
         constantSystem.createString(new DartString.literal(internalName), node);
 
-    Element createInvocationMirror =
-        compiler.findHelper(Compiler.CREATE_INVOCATION_MIRROR);
+    Element createInvocationMirror = backend.getCreateInvocationMirror();
 
     var arguments = new List<HInstruction>();
     if (node.argumentsNode != null) {
       addGenericSendArgumentsToList(node.arguments, arguments);
     }
     var argumentsInstruction = new HLiteralList(arguments);
     add(argumentsInstruction);
 
     var argumentNames = new List<HInstruction>();
     for (SourceString argumentName in selector.namedArguments) {
@@ skipping 365 matching lines @@
     generateError(node,
                   message,
                   backend.getThrowAbstractClassInstantiationError());
   }
 
   void generateThrowNoSuchMethod(Node diagnosticNode,
                                  String methodName,
                                  {Link<Node> argumentNodes,
                                   List<HInstruction> argumentValues,
                                   List<String> existingArguments}) {
-    Element helper =
-        compiler.findHelper(const SourceString('throwNoSuchMethod'));
+    Element helper = backend.getThrowNoSuchMethod();
     Constant receiverConstant =
         constantSystem.createString(new DartString.empty(), diagnosticNode);
     HInstruction receiver = graph.addConstant(receiverConstant);
     DartString dartString = new DartString.literal(methodName);
     Constant nameConstant =
         constantSystem.createString(dartString, diagnosticNode);
     HInstruction name = graph.addConstant(nameConstant);
     if (argumentValues == null) {
       argumentValues = <HInstruction>[];
       argumentNodes.forEach((argumentNode) {
@@ skipping 708 matching lines @@
     HBasicBlock expressionEnd = current;
 
     HSwitch switchInstruction = new HSwitch(<HInstruction>[expression]);
     HBasicBlock expressionBlock = close(switchInstruction);
     JumpHandler jumpHandler = createJumpHandler(node);
     LocalsHandler savedLocals = localsHandler;
 
     List<List<Constant>> matchExpressions = <List<Constant>>[];
     List<HStatementInformation> statements = <HStatementInformation>[];
     bool hasDefault = false;
-    Element getFallThroughErrorElement =
-        compiler.findHelper(const SourceString("getFallThroughError"));
+    Element getFallThroughErrorElement = backend.getFallThroughError();
     HasNextIterator<Node> caseIterator =
         new HasNextIterator<Node>(node.cases.iterator);
     while (caseIterator.hasNext) {
       SwitchCase switchCase = caseIterator.next();
       List<Constant> caseConstants = <Constant>[];
       HBasicBlock block = graph.addNewBlock();
       for (Node labelOrCase in switchCase.labelsAndCases) {
         if (labelOrCase is CaseMatch) {
           Constant constant = constants[labelOrCase];
           caseConstants.add(constant);
@@ skipping 875 matching lines @@
           new HSubGraphBlockInformation(elseBranch.graph));
 
     HBasicBlock conditionStartBlock = conditionBranch.block;
     conditionStartBlock.setBlockFlow(info, joinBlock);
     SubGraph conditionGraph = conditionBranch.graph;
     HIf branch = conditionGraph.end.last;
     assert(branch is HIf);
     branch.blockInformation = conditionStartBlock.blockFlow;
   }
 }