Move remaining helpers to BackendHelpers

pkg/compiler/lib/src/ssa/codegen.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;
 
 class SsaCodeGeneratorTask extends CompilerTask {
 
   final JavaScriptBackend backend;
   final SourceInformationStrategy sourceInformationFactory;
@@ skipping 139 matching lines @@
       controlFlowOperators = new Set<HInstruction>(),
       breakAction = new Map<Entity, EntityAction>(),
       continueAction = new Map<Entity, EntityAction>();
 
   Compiler get compiler => backend.compiler;
 
   NativeEmitter get nativeEmitter => backend.emitter.nativeEmitter;
 
   CodegenRegistry get registry => work.registry;
 
+  BackendHelpers get helpers => backend.helpers;
+
   native.NativeEnqueuer get nativeEnqueuer {
     return compiler.enqueuer.codegen.nativeEnqueuer;
   }
 
   DiagnosticReporter get reporter => compiler.reporter;
 
   CoreClasses get coreClasses => compiler.coreClasses;
 
   bool isGenerateAtUseSite(HInstruction instruction) {
     return generateAtUseSite.contains(instruction);
@@ skipping 529 matching lines @@
   bool visitTryInfo(HTryBlockInformation info) {
     js.Block body = generateStatementsInNewBlock(info.body);
     js.Catch catchPart = null;
     js.Block finallyPart = null;
     if (info.catchBlock != null) {
       void register(ClassElement classElement) {
         if (classElement != null) {
           registry.registerInstantiatedClass(classElement);
         }
       }
-      register(backend.jsPlainJavaScriptObjectClass);
-      register(backend.jsUnknownJavaScriptObjectClass);
+      register(helpers.jsPlainJavaScriptObjectClass);
+      register(helpers.jsUnknownJavaScriptObjectClass);
 
       HLocalValue exception = info.catchVariable;
       String name = variableNames.getName(exception);
       js.VariableDeclaration decl = new js.VariableDeclaration(name);
       js.Block catchBlock = generateStatementsInNewBlock(info.catchBlock);
       catchPart = new js.Catch(decl, catchBlock);
     }
     if (info.finallyBlock != null) {
       finallyPart = generateStatementsInNewBlock(info.finallyBlock);
     }
@@ skipping 795 matching lines @@
       js.Expression receiverExpression = pop();
       use(node.conditionalConstantInterceptor);
       js.Expression constant = pop();
       push(js.js('# && #', [receiverExpression, constant]));
     } else {
       assert(node.inputs.length == 1);
       registry.registerSpecializedGetInterceptor(node.interceptedClasses);
       js.Name name =
           backend.namer.nameForGetInterceptor(node.interceptedClasses);
       var isolate = new js.VariableUse(
-          backend.namer.globalObjectFor(backend.interceptorsLibrary));
+          backend.namer.globalObjectFor(helpers.interceptorsLibrary));
       use(node.receiver);
       List<js.Expression> arguments = <js.Expression>[pop()];
       push(js.propertyCall(isolate, name, arguments)
            .withSourceInformation(node.sourceInformation));
       registry.registerUseInterceptor();
     }
   }
 
   visitInvokeDynamicMethod(HInvokeDynamicMethod node) {
     use(node.receiver);
     js.Expression object = pop();
     String methodName;
     List<js.Expression> arguments = visitArguments(node.inputs);
     Element target = node.element;
 
     // TODO(herhut): The namer should return the appropriate backendname here.
     if (target != null && !node.isInterceptedCall) {
-      if (target == backend.jsArrayAdd) {
+      if (target == helpers.jsArrayAdd) {
         methodName = 'push';
-      } else if (target == backend.jsArrayRemoveLast) {
+      } else if (target == helpers.jsArrayRemoveLast) {
         methodName = 'pop';
-      } else if (target == backend.jsStringSplit) {
+      } else if (target == helpers.jsStringSplit) {
         methodName = 'split';
         // Split returns a List, so we make sure the backend knows the
         // list class is instantiated.
         registry.registerInstantiatedClass(coreClasses.listClass);
       } else if (backend.isNative(target) && target.isFunction
                  && !node.isInterceptedCall) {
         // A direct (i.e. non-interceptor) native call is the result of
         // optimization.  The optimization ensures any type checks or
         // conversions have been satisified.
         methodName = backend.getFixedBackendName(target);
@@ skipping 17 matching lines @@
     js.Name methodName = backend.namer.instanceMethodName(node.element);
     List<js.Expression> arguments = visitArguments(node.inputs);
     push(js.propertyCall(object, methodName, arguments)
          .withSourceInformation(node.sourceInformation));
     registry.registerStaticUse(node.element);
   }
 
   void visitOneShotInterceptor(HOneShotInterceptor node) {
     List<js.Expression> arguments = visitArguments(node.inputs);
     var isolate = new js.VariableUse(
-        backend.namer.globalObjectFor(backend.interceptorsLibrary));
+        backend.namer.globalObjectFor(helpers.interceptorsLibrary));
     Selector selector = node.selector;
     TypeMask mask = getOptimizedSelectorFor(node, selector, node.mask);
     js.Name methodName = backend.registerOneShotInterceptor(selector);
     push(js.propertyCall(isolate, methodName, arguments)
         .withSourceInformation(node.sourceInformation));
     if (selector.isGetter) {
       registerGetter(node);
     } else if (selector.isSetter) {
       registerSetter(node);
     } else {
@@ skipping 193 matching lines @@
 
   visitFieldGet(HFieldGet node) {
     use(node.receiver);
     Element element = node.element;
     if (node.isNullCheck) {
       // We access a JavaScript member we know all objects besides
       // null and undefined have: V8 does not like accessing a member
       // that does not exist.
       push(new js.PropertyAccess.field(pop(), 'toString')
           .withSourceInformation(node.sourceInformation));
-    } else if (element == backend.jsIndexableLength) {
+    } else if (element == helpers.jsIndexableLength) {
       // We're accessing a native JavaScript property called 'length'
       // on a JS String or a JS array. Therefore, the name of that
       // property should not be mangled.
       push(new js.PropertyAccess.field(pop(), 'length')
           .withSourceInformation(node.sourceInformation));
     } else {
       js.Name name = backend.namer.instanceFieldPropertyName(element);
       push(new js.PropertyAccess(pop(), name)
           .withSourceInformation(node.sourceInformation));
       registry.registerFieldGetter(element);
@@ skipping 262 matching lines @@
   visitThis(HThis node) {
     push(new js.This());
   }
 
   visitThrow(HThrow node) {
     if (node.isRethrow) {
       use(node.inputs[0]);
       pushStatement(new js.Throw(pop())
           .withSourceInformation(node.sourceInformation));
     } else {
-      generateThrowWithHelper('wrapException', node.inputs[0],
+      generateThrowWithHelper(helpers.wrapExceptionHelper, node.inputs[0],
           sourceInformation: node.sourceInformation);
     }
   }
 
   visitAwait(HAwait node) {
     use(node.inputs[0]);
     push(new js.Await(pop())
         .withSourceInformation(node.sourceInformation));
   }
 
@@ skipping 40 matching lines @@
       }
       assert(over != null || under != null);
       js.Expression underOver = under == null
           ? over
           : over == null
               ? under
               : new js.Binary("||", under, over);
       js.Statement thenBody = new js.Block.empty();
       js.Block oldContainer = currentContainer;
       currentContainer = thenBody;
-      generateThrowWithHelper('ioore', [node.array, node.reportedIndex]);
+      generateThrowWithHelper(helpers.throwIndexOutOfRangeException,
+          [node.array, node.reportedIndex]);
       currentContainer = oldContainer;
       thenBody = unwrapStatement(thenBody);
       pushStatement(new js.If.noElse(underOver, thenBody)
           .withSourceInformation(node.sourceInformation));
     } else {
-      generateThrowWithHelper('ioore', [node.array, node.index]);
+      generateThrowWithHelper(helpers.throwIndexOutOfRangeException,
+          [node.array, node.index]);
     }
   }
 
-  void generateThrowWithHelper(String helperName, argument,
+  void generateThrowWithHelper(Element helper, argument,
                                {SourceInformation sourceInformation}) {
-    Element helper = backend.findHelper(helperName);
     registry.registerStaticUse(helper);
     js.Expression jsHelper = backend.emitter.staticFunctionAccess(helper);
     List arguments = [];
     var location;
     if (argument is List) {
       location = argument[0];
       argument.forEach((instruction) {
         use(instruction);
         arguments.add(pop());
       });
     } else {
       location = argument;
       use(argument);
       arguments.add(pop());
     }
     js.Call value = new js.Call(jsHelper, arguments.toList(growable: false),
         sourceInformation: sourceInformation);
     // BUG(4906): Using throw/return here adds to the size of the generated code
     // but it has the advantage of explicitly telling the JS engine that
     // this code path will terminate abruptly. Needs more work.
-    if (helperName == 'wrapException') {
+    if (helper == helpers.wrapExceptionHelper) {
       pushStatement(new js.Throw(value)
           .withSourceInformation(sourceInformation));
     } else {
       Element element = work.element;
       if (element is FunctionElement && element.asyncMarker.isYielding) {
         // `return <expr>;` is illegal in a sync* or async* function.
         // To have the the async-translator working, we avoid introducing
         // `return` nodes.
         pushStatement(new js.ExpressionStatement(value)
             .withSourceInformation(sourceInformation));
       } else {
         pushStatement(new js.Return(value)
             .withSourceInformation(sourceInformation));
       }
     }
   }
 
   visitThrowExpression(HThrowExpression node) {
     HInstruction argument = node.inputs[0];
     use(argument);
 
-    Element helper = backend.findHelper("throwExpression");
+    Element helper = helpers.throwExpressionHelper;
     registry.registerStaticUse(helper);
 
     js.Expression jsHelper = backend.emitter.staticFunctionAccess(helper);
     js.Call value = new js.Call(jsHelper, [pop()])
         .withSourceInformation(node.sourceInformation);
     push(value);
   }
 
   void visitSwitch(HSwitch node) {
     // Switches are handled using [visitSwitchInfo].
@@ skipping 210 matching lines @@
   void checkNonNull(HInstruction input) {
     use(input);
     push(new js.Binary('!=', pop(), new js.LiteralNull()));
   }
 
   void checkType(HInstruction input, HInstruction interceptor,
                  DartType type,
                  SourceInformation sourceInformation,
                  {bool negative: false}) {
     Element element = type.element;
-    if (element == backend.jsArrayClass) {
+    if (element == helpers.jsArrayClass) {
       checkArray(input, negative ? '!==': '===');
       return;
-    } else if (element == backend.jsMutableArrayClass) {
+    } else if (element == helpers.jsMutableArrayClass) {
       if (negative) {
         checkImmutableArray(input);
       } else {
         checkMutableArray(input);
       }
       return;
-    } else if (element == backend.jsExtendableArrayClass) {
+    } else if (element == helpers.jsExtendableArrayClass) {
       if (negative) {
         checkFixedArray(input);
       } else {
         checkExtendableArray(input);
       }
       return;
-    } else if (element == backend.jsFixedArrayClass) {
+    } else if (element == helpers.jsFixedArrayClass) {
       if (negative) {
         checkExtendableArray(input);
       } else {
         checkFixedArray(input);
       }
       return;
-    } else if (element == backend.jsUnmodifiableArrayClass) {
+    } else if (element == helpers.jsUnmodifiableArrayClass) {
       if (negative) {
         checkMutableArray(input);
       } else {
         checkImmutableArray(input);
       }
       return;
     }
     if (interceptor != null) {
       checkTypeViaProperty(interceptor, type, sourceInformation,
                            negative: negative);
@@ skipping 218 matching lines @@
     TypeMask inputType = input.instructionType;
     // Figure out if it is beneficial to turn this into a null check.
     // V8 generally prefers 'typeof' checks, but for integers and
     // indexable primitives we cannot compile this test into a single
     // typeof check so the null check is cheaper.
     bool isIntCheck = checkedType.containsOnlyInt(classWorld);
     bool turnIntoNumCheck = isIntCheck && input.isIntegerOrNull(compiler);
     bool turnIntoNullCheck = !turnIntoNumCheck
         && (checkedType.nullable() == inputType)
         && (isIntCheck
-            || checkedType.satisfies(backend.jsIndexableClass, classWorld));
+            || checkedType.satisfies(helpers.jsIndexableClass, classWorld));
 
     if (turnIntoNullCheck) {
       use(input);
       return new js.Binary("==", pop(), new js.LiteralNull())
           .withSourceInformation(input.sourceInformation);
     } else if (isIntCheck && !turnIntoNumCheck) {
       // input is !int
       checkBigInt(input, '!==', input.sourceInformation);
       return pop();
     } else if (turnIntoNumCheck || checkedType.containsOnlyNum(classWorld)) {
@@ skipping 20 matching lines @@
       // sufficient for doing an argument or receiver check.
       assert(compiler.trustTypeAnnotations ||
              !node.checkedType.containsOnlyInt(classWorld) ||
              node.checkedInput.isIntegerOrNull(compiler));
       js.Expression test = generateReceiverOrArgumentTypeTest(
           node.checkedInput, node.checkedType);
       js.Block oldContainer = currentContainer;
       js.Statement body = new js.Block.empty();
       currentContainer = body;
       if (node.isArgumentTypeCheck) {
-        generateThrowWithHelper('iae',
+        generateThrowWithHelper(
+            helpers.throwIllegalArgumentException,
             node.checkedInput,
             sourceInformation: node.sourceInformation);
       } else if (node.isReceiverTypeCheck) {
         use(node.checkedInput);
         js.Name methodName =
             backend.namer.invocationName(node.receiverTypeCheckSelector);
         js.Expression call = js.propertyCall(pop(), methodName, []);
         pushStatement(new js.Return(call));
       }
       currentContainer = oldContainer;
@@ skipping 74 matching lines @@
       var arguments = [
           returnType,
           new js.ArrayInitializer(parameterTypes),
           new js.ObjectInitializer(namedParameters)];
       push(js.js('#(#)', [accessHelper('buildNamedFunctionType'), arguments]));
     }
   }
 
   void visitReadTypeVariable(HReadTypeVariable node) {
     TypeVariableElement element = node.dartType.element;
-    Element helperElement = backend.findHelper('convertRtiToRuntimeType');
+    Element helperElement = helpers.convertRtiToRuntimeType;
     registry.registerStaticUse(helperElement);
 
     use(node.inputs[0]);
     if (node.hasReceiver) {
       if (backend.isInterceptorClass(element.enclosingClass)) {
         int index = element.index;
         js.Expression receiver = pop();
         js.Expression helper = backend.emitter
             .staticFunctionAccess(helperElement);
         push(js.js(r'#(#.$builtinTypeInfo && #.$builtinTypeInfo[#])',
                 [helper, receiver, receiver, js.js.number(index)]));
       } else {
         backend.emitter.registerReadTypeVariable(element);
         push(js.js('#.#()',
                 [pop(), backend.namer.nameForReadTypeVariable(element)]));
       }
     } else {
       push(js.js('#(#)', [
-          backend.emitter.staticFunctionAccess(
-              backend.findHelper('convertRtiToRuntimeType')),
+          backend.emitter.staticFunctionAccess(helperElement),
           pop()]));
     }
   }
 
   void visitInterfaceType(HInterfaceType node) {
     List<js.Expression> typeArguments = <js.Expression>[];
     for (HInstruction type in node.inputs) {
       use(type);
       typeArguments.add(pop());
     }
 
     ClassElement cls = node.dartType.element;
     var arguments = [backend.emitter.typeAccess(cls)];
     if (!typeArguments.isEmpty) {
       arguments.add(new js.ArrayInitializer(typeArguments));
     }
     push(js.js('#(#)', [accessHelper('buildInterfaceType'), arguments]));
   }
 
   void visitVoidType(HVoidType node) {
     push(js.js('#()', accessHelper('getVoidRuntimeType')));
   }
 
   void visitDynamicType(HDynamicType node) {
     push(js.js('#()', accessHelper('getDynamicRuntimeType')));
   }
 
   js.PropertyAccess accessHelper(String name) {
-    Element helper = backend.findHelper(name);
+    Element helper = helpers.findHelper(name);
     if (helper == null) {
       // For mocked-up tests.
       return js.js('(void 0).$name');
     }
     registry.registerStaticUse(helper);
     return backend.emitter.staticFunctionAccess(helper);
   }
 
   @override
   void visitRef(HRef node) {
     visit(node.value);
   }
 }