Merge CommonElements and 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.
 
 import 'dart:math' as math;
 import 'dart:collection' show Queue;
 import '../common.dart';
 import '../common/codegen.dart' show CodegenRegistry, CodegenWorkItem;
 import '../common/tasks.dart' show CompilerTask;
 import '../constants/constant_system.dart';
 import '../constants/values.dart';
 import '../common_elements.dart' show CommonElements;
 import '../elements/elements.dart'
     show AsyncMarker, JumpTarget, LabelDefinition, MethodElement, ResolvedAst;
 import '../elements/entities.dart';
 import '../elements/types.dart';
 import '../io/source_information.dart';
 import '../js/js.dart' as js;
-import '../js_backend/backend_helpers.dart' show BackendHelpers;
 import '../js_backend/interceptor_data.dart';
 import '../js_backend/js_backend.dart';
 import '../js_backend/native_data.dart';
 import '../js_emitter/code_emitter_task.dart';
 import '../native/native.dart' as native;
 import '../options.dart';
 import '../types/types.dart';
 import '../universe/call_structure.dart' show CallStructure;
 import '../universe/selector.dart' show Selector;
 import '../universe/use.dart' show ConstantUse, DynamicUse, StaticUse, TypeUse;
@@ skipping 43 matching lines @@
       CodegenWorkItem work, HGraph graph, ClosedWorld closedWorld) {
     return measure(() {
       backend.tracer.traceGraph("codegen", graph);
       SourceInformation sourceInformation = sourceInformationFactory
           .createBuilderForContext(work.resolvedAst)
           .buildDeclaration(work.resolvedAst);
       SsaCodeGenerator codegen = new SsaCodeGenerator(
           backend.compiler.options,
           backend.emitter,
           backend.nativeCodegenEnqueuer,
-          backend.helpers,
           backend.checkedModeHelpers,
           backend.nativeData,
           backend.interceptorData,
           backend.oneShotInterceptorData,
           backend.rtiSubstitutions,
           backend.rtiEncoder,
           backend.namer,
           backend.superMemberData,
           closedWorld,
           work);
       codegen.visitGraph(graph);
       return new js.Fun(codegen.parameters, codegen.body)
           .withSourceInformation(sourceInformation);
     });
   }
 
   js.Expression generateMethod(
       CodegenWorkItem work, HGraph graph, ClosedWorld closedWorld) {
     return measure(() {
       MethodElement element = work.element;
       if (element.asyncMarker != AsyncMarker.SYNC) {
         work.registry.registerAsyncMarker(element.asyncMarker);
       }
       SsaCodeGenerator codegen = new SsaCodeGenerator(
           backend.compiler.options,
           backend.emitter,
           backend.nativeCodegenEnqueuer,
-          backend.helpers,
           backend.checkedModeHelpers,
           backend.nativeData,
           backend.interceptorData,
           backend.oneShotInterceptorData,
           backend.rtiSubstitutions,
           backend.rtiEncoder,
           backend.namer,
           backend.superMemberData,
           closedWorld,
           work);
@@ skipping 26 matching lines @@
 
   /**
    * Whether we are currently generating expressions instead of statements.
    * This includes declarations, which are generated as expressions.
    */
   bool isGeneratingExpression = false;
 
   final CompilerOptions _options;
   final CodeEmitterTask _emitter;
   final native.NativeCodegenEnqueuer _nativeEnqueuer;
-  final BackendHelpers _helpers;
   final CheckedModeHelpers _checkedModeHelpers;
   final NativeData _nativeData;
   final InterceptorData _interceptorData;
   final OneShotInterceptorData _oneShotInterceptorData;
   final RuntimeTypesSubstitutions _rtiSubstitutions;
   final RuntimeTypesEncoder _rtiEncoder;
   final Namer _namer;
   final SuperMemberData _superMemberData;
   final ClosedWorld _closedWorld;
   final CodegenWorkItem _work;
@@ skipping 38 matching lines @@
   // if branches.
   SubGraph subGraph;
 
   // Pending blocks than need to be visited as part of current subgraph.
   Queue<HBasicBlock> blockQueue;
 
   SsaCodeGenerator(
       this._options,
       this._emitter,
       this._nativeEnqueuer,
-      this._helpers,
       this._checkedModeHelpers,
       this._nativeData,
       this._interceptorData,
       this._oneShotInterceptorData,
       this._rtiSubstitutions,
       this._rtiEncoder,
       this._namer,
       this._superMemberData,
       this._closedWorld,
       this._work,
@@ skipping 612 matching lines @@
     js.Block body = generateStatementsInNewBlock(info.body);
     js.Catch catchPart = null;
     js.Block finallyPart = null;
     if (info.catchBlock != null) {
       void register(ClassEntity classElement) {
         if (classElement != null) {
           _registry.registerInstantiatedClass(classElement);
         }
       }
 
-      register(_helpers.jsPlainJavaScriptObjectClass);
-      register(_helpers.jsUnknownJavaScriptObjectClass);
+      register(_commonElements.jsPlainJavaScriptObjectClass);
+      register(_commonElements.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 821 matching lines @@
       use(node.receiver);
       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 = _namer.nameForGetInterceptor(node.interceptedClasses);
       var isolate = new js.VariableUse(
-          _namer.globalObjectForLibrary(_helpers.interceptorsLibrary));
+          _namer.globalObjectForLibrary(_commonElements.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);
     MemberEntity target = node.element;
 
     // TODO(herhut): The namer should return the appropriate backendname here.
     if (target != null && !node.isInterceptedCall) {
-      if (target == _helpers.jsArrayAdd) {
+      if (target == _commonElements.jsArrayAdd) {
         methodName = 'push';
-      } else if (target == _helpers.jsArrayRemoveLast) {
+      } else if (target == _commonElements.jsArrayRemoveLast) {
         methodName = 'pop';
-      } else if (target == _helpers.jsStringSplit) {
+      } else if (target == _commonElements.jsStringSplit) {
         methodName = 'split';
         // Split returns a List, so we make sure the backend knows the
         // list class is instantiated.
         _registry.registerInstantiatedClass(_commonElements.listClass);
       } else if (_nativeData.isNativeMember(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.
@@ skipping 21 matching lines @@
     push(js
         .propertyCall(object, methodName, arguments)
         .withSourceInformation(node.sourceInformation));
     _registry.registerStaticUse(new StaticUse.constructorBodyInvoke(
         node.element, new CallStructure.unnamed(arguments.length)));
   }
 
   void visitOneShotInterceptor(HOneShotInterceptor node) {
     List<js.Expression> arguments = visitArguments(node.inputs);
     var isolate = new js.VariableUse(
-        _namer.globalObjectForLibrary(_helpers.interceptorsLibrary));
+        _namer.globalObjectForLibrary(_commonElements.interceptorsLibrary));
     Selector selector = node.selector;
     js.Name methodName =
         _oneShotInterceptorData.registerOneShotInterceptor(selector, _namer);
     push(js
         .propertyCall(isolate, methodName, arguments)
         .withSourceInformation(node.sourceInformation));
     if (selector.isGetter) {
       registerGetter(node);
     } else if (selector.isSetter) {
       registerSetter(node);
@@ skipping 119 matching lines @@
     List<DartType> instantiatedTypes = node.instantiatedTypes;
 
     if (instantiatedTypes != null && !instantiatedTypes.isEmpty) {
       instantiatedTypes.forEach((type) {
         _registry.registerInstantiation(type);
       });
     }
 
     List<js.Expression> arguments = visitArguments(node.inputs, start: 0);
 
-    if (element == _helpers.checkConcurrentModificationError) {
+    if (element == _commonElements.checkConcurrentModificationError) {
       // Manually inline the [checkConcurrentModificationError] function.  This
       // function is only called from a for-loop update.  Ideally we would just
       // generate the conditionalcontrol flow in the builder but it adds basic
       // blocks in the loop update that interfere with other optimizations and
       // confuses loop recognition.
 
       assert(arguments.length == 2);
-      FunctionEntity throwFunction = _helpers.throwConcurrentModificationError;
+      FunctionEntity throwFunction =
+          _commonElements.throwConcurrentModificationError;
       _registry.registerStaticUse(
           new StaticUse.staticInvoke(throwFunction, CallStructure.ONE_ARG));
 
       // Calling using `(0, #)(#)` instead of `#(#)` separates the property load
       // of the static function access from the call.  For some reason this
       // helps V8 see that the call never happens so V8 makes the call a
       // deoptimization. This removes the call from the optimized loop, making
       // more optimizations available to the loop.  This form is 50% faster on
       // some small loop, almost as fast as loops with no concurrent
       // modification check.
@@ skipping 34 matching lines @@
       }
     } else {
       Selector selector = node.selector;
       if (!_superMemberData.maybeRegisterAliasedSuperMember(
           superElement, selector)) {
         js.Name methodName;
         if (selector.isGetter && !superElement.isGetter) {
           // If this is a tear-off, register the fact that a tear-off closure
           // will be created, and that this tear-off must bypass ordinary
           // dispatch to ensure the super method is invoked.
-          FunctionEntity helper = _helpers.closureFromTearOff;
+          FunctionEntity helper = _commonElements.closureFromTearOff;
           _registry.registerStaticUse(new StaticUse.staticInvoke(
               helper, new CallStructure.unnamed(node.inputs.length)));
           _registry.registerStaticUse(new StaticUse.superTearOff(node.element));
           methodName = _namer.invocationName(selector);
         } else {
           methodName = _namer.instanceMethodName(superElement);
         }
         _registry.registerStaticUse(new StaticUse.superInvoke(
             superElement, new CallStructure.unnamed(node.inputs.length)));
         push(js.js('#.#.call(#)', [
@@ skipping 294 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(_helpers.wrapExceptionHelper, node.inputs[0],
+      generateThrowWithHelper(
+          _commonElements.wrapExceptionHelper, node.inputs[0],
           sourceInformation: node.sourceInformation);
     }
   }
 
   visitAwait(HAwait node) {
     use(node.inputs[0]);
     push(new js.Await(pop()).withSourceInformation(node.sourceInformation));
   }
 
   visitYield(HYield node) {
@@ skipping 37 matching lines @@
         use(node.length);
         over = new js.Binary(">=", jsIndex, pop());
       }
       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(_helpers.throwIndexOutOfRangeException,
+      generateThrowWithHelper(_commonElements.throwIndexOutOfRangeException,
           [node.array, node.reportedIndex]);
       currentContainer = oldContainer;
       thenBody = unwrapStatement(thenBody);
       pushStatement(new js.If.noElse(underOver, thenBody)
           .withSourceInformation(node.sourceInformation));
     } else {
-      generateThrowWithHelper(
-          _helpers.throwIndexOutOfRangeException, [node.array, node.index]);
+      generateThrowWithHelper(_commonElements.throwIndexOutOfRangeException,
+          [node.array, node.index]);
     }
   }
 
   void generateThrowWithHelper(FunctionEntity helper, argument,
       {SourceInformation sourceInformation}) {
     js.Expression jsHelper = _emitter.staticFunctionAccess(helper);
     List arguments = [];
     if (argument is List) {
       argument.forEach((instruction) {
         use(instruction);
         arguments.add(pop());
       });
     } else {
       use(argument);
       arguments.add(pop());
     }
     _registry.registerStaticUse(new StaticUse.staticInvoke(
         helper, new CallStructure.unnamed(arguments.length)));
     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 (helper == _helpers.wrapExceptionHelper) {
+    if (helper == _commonElements.wrapExceptionHelper) {
       pushStatement(
           new js.Throw(value).withSourceInformation(sourceInformation));
     } else {
       Entity element = _work.element;
       if (element is MethodElement && element.asyncMarker.isYielding) {
         // `return <expr>;` is illegal in a sync* or async* function.
         // To have 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);
 
-    FunctionEntity helper = _helpers.throwExpressionHelper;
+    FunctionEntity helper = _commonElements.throwExpressionHelper;
     _registry.registerStaticUse(
         new StaticUse.staticInvoke(helper, CallStructure.ONE_ARG));
 
     js.Expression jsHelper = _emitter.staticFunctionAccess(helper);
     js.Call value = new js.Call(jsHelper, [pop()])
         .withSourceInformation(node.sourceInformation);
     push(value);
   }
 
   void visitSwitch(HSwitch node) {
@@ skipping 52 matching lines @@
       if (node.usedBy.length == 1 &&
           node.usedBy[0] is HStringConcat &&
           node.usedBy[0].inputs[1] == node) {
         // The context is already <string> + value.
       } else {
         // Force an empty string for the first operand.
         push(new js.Binary('+', js.string(""), pop())
             .withSourceInformation(node.sourceInformation));
       }
     } else {
-      FunctionEntity convertToString = _helpers.stringInterpolationHelper;
+      FunctionEntity convertToString =
+          _commonElements.stringInterpolationHelper;
       _registry.registerStaticUse(
           new StaticUse.staticInvoke(convertToString, CallStructure.ONE_ARG));
       js.Expression jsHelper = _emitter.staticFunctionAccess(convertToString);
       use(input);
       push(new js.Call(jsHelper, <js.Expression>[pop()],
           sourceInformation: node.sourceInformation));
     }
   }
 
   void visitLiteralList(HLiteralList node) {
@@ skipping 140 matching lines @@
     use(input);
     push(new js.Binary('!=', pop(), new js.LiteralNull()));
   }
 
   void checkType(HInstruction input, HInstruction interceptor, DartType type,
       SourceInformation sourceInformation,
       {bool negative: false}) {
     if (type.isInterfaceType) {
       InterfaceType interfaceType = type;
       ClassEntity element = interfaceType.element;
-      if (element == _helpers.jsArrayClass) {
+      if (element == _commonElements.jsArrayClass) {
         checkArray(input, negative ? '!==' : '===');
         return;
-      } else if (element == _helpers.jsMutableArrayClass) {
+      } else if (element == _commonElements.jsMutableArrayClass) {
         if (negative) {
           checkImmutableArray(input);
         } else {
           checkMutableArray(input);
         }
         return;
-      } else if (element == _helpers.jsExtendableArrayClass) {
+      } else if (element == _commonElements.jsExtendableArrayClass) {
         if (negative) {
           checkFixedArray(input);
         } else {
           checkExtendableArray(input);
         }
         return;
-      } else if (element == _helpers.jsFixedArrayClass) {
+      } else if (element == _commonElements.jsFixedArrayClass) {
         if (negative) {
           checkExtendableArray(input);
         } else {
           checkFixedArray(input);
         }
         return;
-      } else if (element == _helpers.jsUnmodifiableArrayClass) {
+      } else if (element == _commonElements.jsUnmodifiableArrayClass) {
         if (negative) {
           checkMutableArray(input);
         } else {
           checkImmutableArray(input);
         }
         return;
       }
     }
     if (interceptor != null) {
       checkTypeViaProperty(interceptor, type, sourceInformation,
@@ skipping 203 matching lines @@
     // 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(_closedWorld);
     bool turnIntoNumCheck =
         isIntCheck && inputType.containsOnlyInt(_closedWorld);
     bool turnIntoNullCheck = !turnIntoNumCheck &&
         (checkedType.nullable() == inputType) &&
         (isIntCheck ||
-            checkedType.satisfies(_helpers.jsIndexableClass, _closedWorld));
+            checkedType.satisfies(
+                _commonElements.jsIndexableClass, _closedWorld));
 
     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(_closedWorld)) {
@@ skipping 14 matching lines @@
   }
 
   void visitTypeConversion(HTypeConversion node) {
     if (node.isArgumentTypeCheck || node.isReceiverTypeCheck) {
       js.Expression test = generateReceiverOrArgumentTypeTest(node);
       js.Block oldContainer = currentContainer;
       js.Statement body = new js.Block.empty();
       currentContainer = body;
       if (node.isArgumentTypeCheck) {
         generateThrowWithHelper(
-            _helpers.throwIllegalArgumentException, node.checkedInput,
+            _commonElements.throwIllegalArgumentException, node.checkedInput,
             sourceInformation: node.sourceInformation);
       } else if (node.isReceiverTypeCheck) {
         use(node.checkedInput);
         js.Name methodName =
             _namer.invocationName(node.receiverTypeCheckSelector);
         js.Expression call = js.propertyCall(pop(), methodName, []);
         pushStatement(new js.Return(call));
       }
       currentContainer = oldContainer;
       body = unwrapStatement(body);
@@ skipping 15 matching lines @@
     _registry.registerTypeUse(new TypeUse.isCheck(type));
 
     CheckedModeHelper helper;
     if (node.isBooleanConversionCheck) {
       helper = const CheckedModeHelper('boolConversionCheck');
     } else {
       helper = _checkedModeHelpers.getCheckedModeHelper(type,
           typeCast: node.isCastTypeCheck);
     }
 
-    StaticUse staticUse = helper.getStaticUse(_helpers);
+    StaticUse staticUse = helper.getStaticUse(_commonElements);
     _registry.registerStaticUse(staticUse);
     List<js.Expression> arguments = <js.Expression>[];
     use(node.checkedInput);
     arguments.add(pop());
     helper.generateAdditionalArguments(this, _namer, node, arguments);
     push(new js.Call(
         _emitter.staticFunctionAccess(staticUse.element), arguments));
   }
 
   void visitTypeKnown(HTypeKnown node) {
@@ skipping 11 matching lines @@
     TypeVariableEntity element = node.variable.element;
 
     int index = element.index;
     HInstruction object = node.object;
     use(object);
     js.Expression receiver = pop();
 
     if (typeVariableAccessNeedsSubstitution(element, object.instructionType)) {
       js.Expression typeName =
           js.quoteName(_namer.runtimeTypeName(element.typeDeclaration));
-      FunctionEntity helperElement = _helpers.getRuntimeTypeArgument;
+      FunctionEntity helperElement = _commonElements.getRuntimeTypeArgument;
       _registry.registerStaticUse(
           new StaticUse.staticInvoke(helperElement, CallStructure.THREE_ARGS));
       js.Expression helper = _emitter.staticFunctionAccess(helperElement);
       push(js.js(
           r'#(#, #, #)', [helper, receiver, typeName, js.js.number(index)]));
     } else {
-      FunctionEntity helperElement = _helpers.getTypeArgumentByIndex;
+      FunctionEntity helperElement = _commonElements.getTypeArgumentByIndex;
       _registry.registerStaticUse(
           new StaticUse.staticInvoke(helperElement, CallStructure.TWO_ARGS));
       js.Expression helper = _emitter.staticFunctionAccess(helperElement);
       push(js.js(r'#(#, #)', [helper, receiver, js.js.number(index)]));
     }
   }
 
   void visitTypeInfoExpression(HTypeInfoExpression node) {
     List<js.Expression> arguments = <js.Expression>[];
     for (HInstruction input in node.inputs) {
@@ skipping 40 matching lines @@
     return _closedWorld.anyStrictSubclassOf(cls, (ClassEntity subclass) {
       return !_rtiSubstitutions.isTrivialSubstitution(subclass, cls);
     });
   }
 
   @override
   void visitRef(HRef node) {
     visit(node.value);
   }
 }