Introduce BackendImpact to separate enqueueing from data.

pkg/compiler/lib/src/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;
 
 class SsaFunctionCompiler implements FunctionCompiler {
   final SsaCodeGeneratorTask generator;
   final SsaBuilderTask builder;
   final SsaOptimizerTask optimizer;
@@ skipping 1089 matching lines @@
       this.rti = backend.rti,
       this.elements = work.resolutionTree {
     graph.element = work.element;
     localsHandler = new LocalsHandler(this, work.element, null);
     sourceElementStack.add(work.element);
     sourceInformationBuilder =
         sourceInformationFactory.createBuilderForContext(
             work.element.implementation);
   }
 
+  BackendHelpers get helpers => backend.helpers;
 
   DiagnosticReporter get reporter => compiler.reporter;
 
   // TODO(johnniwinther): Avoid the need for this.
   Resolution get resolution => compiler.resolution;
 
   @override
   SemanticSendVisitor get sendVisitor => this;
 
   @override
@@ skipping 1113 matching lines @@
       /// Helper to identify instructions that read a type variable without
       /// substitution (that is, directly use the index). These instructions
       /// are of the form:
       ///   HInvokeStatic(getTypeArgumentByIndex, this, index)
       ///
       /// Return `true` if [instruction] is of that form and the index is the
       /// next index in the sequence (held in [expectedIndex]).
       bool isIndexedTypeArgumentGet(HInstruction instruction) {
         if (instruction is! HInvokeStatic) return false;
         HInvokeStatic invoke = instruction;
-        if (invoke.element != backend.getGetTypeArgumentByIndex()) {
+        if (invoke.element != helpers.getTypeArgumentByIndex) {
           return false;
         }
         HConstant index = invoke.inputs[1];
         HInstruction newSource = invoke.inputs[0];
         if (newSource is! HThis) {
           return false;
         }
         if (source == null) {
           // This is the first match. Extract the context class for the type
           // variables and get the list of type variables to keep track of how
@@ skipping 303 matching lines @@
   }
 
   void assertIsSubtype(ast.Node node, DartType subtype, DartType supertype,
                        String message) {
     HInstruction subtypeInstruction =
         analyzeTypeArgument(localsHandler.substInContext(subtype));
     HInstruction supertypeInstruction =
         analyzeTypeArgument(localsHandler.substInContext(supertype));
     HInstruction messageInstruction =
         graph.addConstantString(new ast.DartString.literal(message), compiler);
-    Element element = backend.getAssertIsSubtype();
+    Element element = helpers.assertIsSubtype;
     var inputs = <HInstruction>[subtypeInstruction, supertypeInstruction,
                                 messageInstruction];
     HInstruction assertIsSubtype = new HInvokeStatic(
         element, inputs, subtypeInstruction.instructionType);
     registry.registerTypeVariableBoundsSubtypeCheck(subtype, supertype);
     add(assertIsSubtype);
   }
 
   HGraph closeFunction() {
     // TODO(kasperl): Make this goto an implicit return.
@@ skipping 51 matching lines @@
 
   visitAssert(ast.Assert node) {
     if (!compiler.enableUserAssertions) return;
 
     if (!node.hasMessage) {
       // Generate:
       //
       //     assertHelper(condition);
       //
       visit(node.condition);
-      pushInvokeStatic(node, backend.assertHelperMethod, [pop()]);
+      pushInvokeStatic(node, helpers.assertHelper, [pop()]);
       pop();
       return;
     }
     // Assert has message. Generate:
     //
     //     if (assertTest(condition)) assertThrow(message);
     //
     void buildCondition() {
       visit(node.condition);
-      pushInvokeStatic(node, backend.assertTestMethod, [pop()]);
+      pushInvokeStatic(node, helpers.assertTest, [pop()]);
     }
     void fail() {
       visit(node.message);
-      pushInvokeStatic(node, backend.assertThrowMethod, [pop()]);
+      pushInvokeStatic(node, helpers.assertThrow, [pop()]);
       pop();
     }
     handleIf(node,
              visitCondition: buildCondition,
              visitThen: fail);
   }
 
   visitBlock(ast.Block node) {
     assert(!isAborted());
     if (!isReachable) return;  // This can only happen when inlining.
@@ skipping 722 matching lines @@
   /// Inserts a call to checkDeferredIsLoaded for [prefixElement].
   /// If [prefixElement] is [null] ndo nothing.
   void generateIsDeferredLoadedCheckIfNeeded(PrefixElement prefixElement,
                                              ast.Node location) {
     if (prefixElement == null) return;
     String loadId =
         compiler.deferredLoadTask.getImportDeferName(location, prefixElement);
     HInstruction loadIdConstant = addConstantString(loadId);
     String uri = prefixElement.deferredImport.uri.toString();
     HInstruction uriConstant = addConstantString(uri);
-    Element helper = backend.getCheckDeferredIsLoaded();
+    Element helper = helpers.checkDeferredIsLoaded;
     pushInvokeStatic(location, helper, [loadIdConstant, uriConstant]);
     pop();
   }
 
   /// Inserts a call to checkDeferredIsLoaded if the send has a prefix that
   /// resolves to a deferred library.
   void generateIsDeferredLoadedCheckOfSend(ast.Send node) {
     generateIsDeferredLoadedCheckIfNeeded(
         compiler.deferredLoadTask.deferredPrefixElement(node, elements),
         node);
@@ skipping 417 matching lines @@
       pushInvokeDynamic(
           node,
           new Selector.call(
               new PrivateName('_isTest', backend.jsHelperLibrary),
               CallStructure.ONE_ARG),
           null,
           arguments);
       return new HIs.compound(type, expression, pop(), backend.boolType);
     } else if (type.isTypeVariable) {
       HInstruction runtimeType = addTypeVariableReference(type);
-      Element helper = backend.getCheckSubtypeOfRuntimeType();
+      Element helper = helpers.checkSubtypeOfRuntimeType;
       List<HInstruction> inputs = <HInstruction>[expression, runtimeType];
       pushInvokeStatic(null, helper, inputs, typeMask: backend.boolType);
       HInstruction call = pop();
       return new HIs.variable(type, expression, call, backend.boolType);
     } else if (RuntimeTypes.hasTypeArguments(type)) {
       ClassElement element = type.element;
-      Element helper = backend.getCheckSubtype();
+      Element helper = helpers.checkSubtype;
       HInstruction representations =
           buildTypeArgumentRepresentations(type);
       add(representations);
       js.Name operator = backend.namer.operatorIs(element);
       HInstruction isFieldName = addConstantStringFromName(operator);
       HInstruction asFieldName = compiler.world.hasAnyStrictSubtype(element)
           ? addConstantStringFromName(backend.namer.substitutionName(element))
           : graph.addConstantNull(compiler);
       List<HInstruction> inputs = <HInstruction>[expression,
                                                  isFieldName,
@@ skipping 649 matching lines @@
       registry.registerSelectorUse(selector);
     }
     String publicName = name;
     if (selector.isSetter) publicName += '=';
 
     ConstantValue nameConstant = constantSystem.createString(
         new ast.DartString.literal(publicName));
 
     js.Name internalName = backend.namer.invocationName(selector);
 
-    Element createInvocationMirror = backend.getCreateInvocationMirror();
+    Element createInvocationMirror = helpers.createInvocationMirror;
     var argumentsInstruction = buildLiteralList(arguments);
     add(argumentsInstruction);
 
     var argumentNames = new List<HInstruction>();
     for (String argumentName in selector.namedArguments) {
       ConstantValue argumentNameConstant =
           constantSystem.createString(new ast.DartString.literal(argumentName));
       argumentNames.add(graph.addConstant(argumentNameConstant, compiler));
     }
     var argumentNamesInstruction = buildLiteralList(argumentNames);
@@ skipping 282 matching lines @@
         compiler);
 
     if (needsSubstitutionForTypeVariableAccess(cls)) {
       // TODO(ahe): Creating a string here is unfortunate. It is slow (due to
       // string concatenation in the implementation), and may prevent
       // segmentation of '$'.
       js.Name substitutionName = backend.namer.runtimeTypeName(cls);
       HInstruction substitutionNameInstr = graph.addConstantStringFromName(
           substitutionName, compiler);
       pushInvokeStatic(null,
-                       backend.getGetRuntimeTypeArgument(),
+                       helpers.getRuntimeTypeArgument,
                        [target, substitutionNameInstr, index],
                        typeMask: backend.dynamicType,
                        sourceInformation: sourceInformation);
     } else {
       pushInvokeStatic(
           null,
-          backend.getGetTypeArgumentByIndex(),
+          helpers.getTypeArgumentByIndex,
           [target, index],
           typeMask: backend.dynamicType,
           sourceInformation: sourceInformation);
     }
     return pop();
   }
 
   // TODO(karlklose): this is needed to avoid a bug where the resolved type is
   // not stored on a type annotation in the closure translator. Remove when
   // fixed.
@@ skipping 105 matching lines @@
     type = localsHandler.substInContext(type);
     type.typeArguments.forEach((DartType argument) {
       inputs.add(analyzeTypeArgument(argument));
     });
     // TODO(15489): Register at codegen.
     registry.registerInstantiatedType(type);
     return callSetRuntimeTypeInfo(type.element, inputs, newObject);
   }
 
   void copyRuntimeTypeInfo(HInstruction source, HInstruction target) {
-    Element copyHelper = backend.getCopyTypeArguments();
+    Element copyHelper = helpers.copyTypeArguments;
     pushInvokeStatic(null, copyHelper, [source, target],
         sourceInformation: target.sourceInformation);
     pop();
   }
 
   HInstruction callSetRuntimeTypeInfo(ClassElement element,
                                       List<HInstruction> rtiInputs,
                                       HInstruction newObject) {
     if (!backend.classNeedsRti(element) || element.typeVariables.isEmpty) {
       return newObject;
     }
 
     HInstruction typeInfo = buildLiteralList(rtiInputs);
     add(typeInfo);
 
     // Set the runtime type information on the object.
-    Element typeInfoSetterElement = backend.getSetRuntimeTypeInfo();
+    Element typeInfoSetterElement = helpers.setRuntimeTypeInfo;
     pushInvokeStatic(
         null,
         typeInfoSetterElement,
         <HInstruction>[newObject, typeInfo],
         typeMask: backend.dynamicType,
         sourceInformation: newObject.sourceInformation);
 
     // The new object will now be referenced through the
     // `setRuntimeTypeInfo` call. We therefore set the type of that
     // instruction to be of the object's type.
@@ skipping 559 matching lines @@
     }
   }
 
   /// Generate the literal for [typeVariable] in the current context.
   void generateTypeVariableLiteral(ast.Send node,
                                    TypeVariableType typeVariable) {
     DartType type = localsHandler.substInContext(typeVariable);
     HInstruction value = analyzeTypeArgument(type,
         sourceInformation: sourceInformationBuilder.buildGet(node));
     pushInvokeStatic(node,
-                     backend.getRuntimeTypeToString(),
+                     helpers.runtimeTypeToString,
                      [value],
                      typeMask: backend.stringType);
     pushInvokeStatic(node,
-                     backend.getCreateRuntimeType(),
+                     helpers.createRuntimeType,
                      [pop()]);
   }
 
   /// Generate a call to a type literal.
   void generateTypeLiteralCall(ast.Send node) {
     // This send is of the form 'e(...)', where e is resolved to a type
     // reference. We create a regular closure call on the result of the type
     // reference instead of creating a NoSuchMethodError to avoid pulling it
     // in if it is not used (e.g., in a try/catch).
     HInstruction target = pop();
@@ skipping 22 matching lines @@
   internalError(Spannable node, String reason) {
     reporter.internalError(node, reason);
   }
 
   void generateError(ast.Node node, String message, Element helper) {
     HInstruction errorMessage = addConstantString(message);
     pushInvokeStatic(node, helper, [errorMessage]);
   }
 
   void generateRuntimeError(ast.Node node, String message) {
-    generateError(node, message, backend.getThrowRuntimeError());
+    generateError(node, message, helpers.throwRuntimeError);
   }
 
   void generateTypeError(ast.Node node, String message) {
-    generateError(node, message, backend.getThrowTypeError());
+    generateError(node, message, helpers.throwTypeError);
   }
 
   void generateAbstractClassInstantiationError(ast.Node node, String message) {
     generateError(node,
                   message,
-                  backend.getThrowAbstractClassInstantiationError());
+                  helpers.throwAbstractClassInstantiationError);
   }
 
   void generateThrowNoSuchMethod(ast.Node diagnosticNode,
                                  String methodName,
                                  {Link<ast.Node> argumentNodes,
                                   List<HInstruction> argumentValues,
                                   List<String> existingArguments,
                                   SourceInformation sourceInformation}) {
-    Element helper = backend.getThrowNoSuchMethod();
+    Element helper = helpers.throwNoSuchMethod;
     ConstantValue receiverConstant =
         constantSystem.createString(new ast.DartString.empty());
     HInstruction receiver = graph.addConstant(receiverConstant, compiler);
     ast.DartString dartString = new ast.DartString.literal(methodName);
     ConstantValue nameConstant = constantSystem.createString(dartString);
     HInstruction name = graph.addConstant(nameConstant, compiler);
     if (argumentValues == null) {
       argumentValues = <HInstruction>[];
       argumentNodes.forEach((argumentNode) {
         visit(argumentNode);
@@ skipping 1587 matching lines @@
     return new JumpHandler(this, element);
   }
 
   visitAsyncForIn(ast.AsyncForIn node) {
     // The async-for is implemented with a StreamIterator.
     HInstruction streamIterator;
 
     visit(node.expression);
     HInstruction expression = pop();
     pushInvokeStatic(node,
-                     backend.getStreamIteratorConstructor(),
+                     helpers.streamIteratorConstructor,
                      [expression, graph.addConstantNull(compiler)]);
     streamIterator = pop();
 
     void buildInitializer() {}
 
     HInstruction buildCondition() {
       Selector selector = elements.getMoveNextSelector(node);
       TypeMask mask = elements.getMoveNextTypeMask(node);
       pushInvokeDynamic(node, selector, mask, [streamIterator]);
       HInstruction future = pop();
@@ skipping 164 matching lines @@
     void buildConcurrentModificationErrorCheck() {
       if (originalLength == null) return;
       // The static call checkConcurrentModificationError() is expanded in
       // codegen to:
       //
       //     array.length == _end || throwConcurrentModificationError(array)
       //
       HInstruction length = buildGetLength();
       push(new HIdentity(length, originalLength, null, boolType));
       pushInvokeStatic(node,
-          backend.getCheckConcurrentModificationError(),
+          helpers.checkConcurrentModificationError,
           [pop(), array]);
       pop();
     }
 
     void buildInitializer() {
       visit(node.expression);
       array = pop();
       isFixed = isFixedLength(array.instructionType, compiler);
       localsHandler.updateLocal(indexVariable,
           graph.addConstantInt(0, compiler));
@@ skipping 441 matching lines @@
     if (switchCases.isEmpty) {
       return;
     }
 
     HSwitch switchInstruction = new HSwitch(<HInstruction>[expression]);
     HBasicBlock expressionEnd = close(switchInstruction);
     LocalsHandler savedLocals = localsHandler;
 
     List<HStatementInformation> statements = <HStatementInformation>[];
     bool hasDefault = false;
-    Element getFallThroughErrorElement = backend.getFallThroughError();
+    Element getFallThroughErrorElement = helpers.fallThroughError;
     HasNextIterator<ast.Node> caseIterator =
         new HasNextIterator<ast.Node>(switchCases.iterator);
     while (caseIterator.hasNext) {
       ast.SwitchCase switchCase = caseIterator.next();
       HBasicBlock block = graph.addNewBlock();
       for (ConstantValue constant in getConstants(switchCase)) {
         HConstant hConstant = graph.addConstant(constant, compiler);
         switchInstruction.inputs.add(hConstant);
         hConstant.usedBy.add(switchInstruction);
         expressionEnd.addSuccessor(block);
@@ skipping 225 matching lines @@
       startCatchBlock = graph.addNewBlock();
       open(startCatchBlock);
       // Note that the name of this local is irrelevant.
       SyntheticLocal local =
           new SyntheticLocal('exception', localsHandler.executableContext);
       exception = new HLocalValue(local, backend.nonNullType);
       add(exception);
       HInstruction oldRethrowableException = rethrowableException;
       rethrowableException = exception;
 
-      pushInvokeStatic(node, backend.getExceptionUnwrapper(), [exception]);
+      pushInvokeStatic(node, helpers.exceptionUnwrapper, [exception]);
       HInvokeStatic unwrappedException = pop();
       tryInstruction.exception = exception;
       Link<ast.Node> link = node.catchBlocks.nodes;
 
       void pushCondition(ast.CatchBlock catchBlock) {
         if (catchBlock.onKeyword != null) {
           DartType type = elements.getType(catchBlock.type);
           if (type == null) {
             reporter.internalError(catchBlock.type, 'On with no type.');
           }
@@ skipping 25 matching lines @@
         ast.CatchBlock catchBlock = link.head;
         link = link.tail;
         if (catchBlock.exception != null) {
           LocalVariableElement exceptionVariable =
               elements[catchBlock.exception];
           localsHandler.updateLocal(exceptionVariable,
                                     unwrappedException);
         }
         ast.Node trace = catchBlock.trace;
         if (trace != null) {
-          pushInvokeStatic(trace, backend.getTraceFromException(), [exception]);
+          pushInvokeStatic(trace, helpers.traceFromException, [exception]);
           HInstruction traceInstruction = pop();
           LocalVariableElement traceVariable = elements[trace];
           localsHandler.updateLocal(traceVariable, traceInstruction);
         }
         visit(catchBlock);
       }
 
       void visitElse() {
         if (link.isEmpty) {
           closeAndGotoExit(
@@ skipping 828 matching lines @@
     if (unaliased is TypedefType) throw 'unable to unalias $type';
     unaliased.accept(this, builder);
   }
 
   void visitDynamicType(DynamicType type, SsaBuilder builder) {
     JavaScriptBackend backend = builder.compiler.backend;
     ClassElement cls = backend.findHelper('DynamicRuntimeType');
     builder.push(new HDynamicType(type, new TypeMask.exact(cls, classWorld)));
   }
 }