Set runtime type information when converting list literals.

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.
 
 import 'dart:collection';
 
 import 'package:js_runtime/shared/embedded_names.dart';
 
 import '../closure.dart';
 import '../common.dart';
@@ skipping 725 matching lines @@
             },
             visitElse: null,
             sourceInformation: sourceInformationBuilder.buildIf(function.body));
       }
     }
     if (const bool.fromEnvironment('unreachable-throw')) {
       var emptyParameters =
           parameters.values.where((p) => p.instructionType.isEmpty);
       if (emptyParameters.length > 0) {
         addComment('${emptyParameters} inferred as [empty]');
-        pushInvokeStatic(function.body, helpers.assertUnreachableMethod, []);
+        pushInvokeStatic(helpers.assertUnreachableMethod, [],
+            location: function.body);
         pop();
         return closeFunction();
       }
     }
     function.body.accept(this);
     return closeFunction();
   }
 
   /// Adds a JavaScript comment to the output. The comment will be omitted in
   /// minified mode.  Each line in [text] is preceded with `//` and indented.
@@ skipping 840 matching lines @@
 
   visitAssert(ast.Assert node) {
     if (!compiler.options.enableUserAssertions) return;
 
     if (!node.hasMessage) {
       // Generate:
       //
       //     assertHelper(condition);
       //
       visit(node.condition);
-      pushInvokeStatic(node, helpers.assertHelper, [pop()]);
+      pushInvokeStatic(helpers.assertHelper, [pop()], location: node);
       pop();
       return;
     }
     // Assert has message. Generate:
     //
     //     if (assertTest(condition)) assertThrow(message);
     //
     void buildCondition() {
       visit(node.condition);
-      pushInvokeStatic(node, helpers.assertTest, [pop()]);
+      pushInvokeStatic(helpers.assertTest, [pop()], location: node);
     }
 
     void fail() {
       visit(node.message);
-      pushInvokeStatic(node, helpers.assertThrow, [pop()]);
+      pushInvokeStatic(helpers.assertThrow, [pop()], location: node);
       pop();
     }
 
     handleIf(node: node, visitCondition: buildCondition, visitThen: fail);
   }
 
   visitBlock(ast.Block node) {
     assert(!isAborted());
     if (!isReachable) return; // This can only happen when inlining.
     for (Link<ast.Node> link = node.statements.nodes;
@@ skipping 457 matching lines @@
   /// 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 = helpers.checkDeferredIsLoaded;
-    pushInvokeStatic(location, helper, [loadIdConstant, uriConstant]);
+    pushInvokeStatic(helper, [loadIdConstant, uriConstant], location: location);
     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 80 matching lines @@
     }
   }
 
   /// Generate a getter invocation of the static or top level [getter].
   void generateStaticGetterGet(ast.Send node, MethodElement getter) {
     SourceInformation sourceInformation =
         sourceInformationBuilder.buildGet(node);
     if (getter.isDeferredLoaderGetter) {
       generateDeferredLoaderGet(node, getter, sourceInformation);
     } else {
-      pushInvokeStatic(node, getter, <HInstruction>[],
-          sourceInformation: sourceInformation);
+      pushInvokeStatic(getter, <HInstruction>[],
+          sourceInformation: sourceInformation, location: node);
     }
   }
 
   /// Generate a dynamic getter invocation.
   void generateDynamicGet(ast.Send node) {
     HInstruction receiver = generateInstanceSendReceiver(node);
     generateInstanceGetterWithCompiledReceiver(node, elements.getSelector(node),
         elementInferenceResults.typeOfSend(node), receiver);
   }
 
@@ skipping 137 matching lines @@
       {ast.Node location}) {
     if (location == null) {
       assert(send != null);
       location = send;
     }
     assert(invariant(
         location, send == null || !Elements.isInstanceSend(send, elements),
         message: "Unexpected non instance setter: $element."));
     if (Elements.isStaticOrTopLevelField(element)) {
       if (element.isSetter) {
-        pushInvokeStatic(location, element, <HInstruction>[value]);
+        pushInvokeStatic(element, <HInstruction>[value], location: location);
         pop();
       } else {
         FieldElement field = element;
         value = typeBuilder.potentiallyCheckOrTrustType(value, field.type);
         addWithPosition(new HStaticStore(field, value), location);
       }
       stack.add(value);
     } else if (Elements.isError(element)) {
       generateNoSuchSetter(location, element, send == null ? null : value);
     } else if (Elements.isMalformed(element)) {
@@ skipping 87 matching lines @@
           new Selector.call(new PrivateName('_isTest', helpers.jsHelperLibrary),
               CallStructure.ONE_ARG),
           null,
           arguments);
       return new HIs.compound(type, expression, pop(), backend.boolType);
     } else if (type.isTypeVariable) {
       HInstruction runtimeType =
           typeBuilder.addTypeVariableReference(type, sourceElement);
       Element helper = helpers.checkSubtypeOfRuntimeType;
       List<HInstruction> inputs = <HInstruction>[expression, runtimeType];
-      pushInvokeStatic(null, helper, inputs, typeMask: backend.boolType);
+      pushInvokeStatic(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 = helpers.checkSubtype;
       HInstruction representations =
           typeBuilder.buildTypeArgumentRepresentations(type, sourceElement);
       add(representations);
       js.Name operator = backend.namer.operatorIs(element);
       HInstruction isFieldName = addConstantStringFromName(operator);
       HInstruction asFieldName = compiler.closedWorld
               .hasAnyStrictSubtype(element)
           ? addConstantStringFromName(backend.namer.substitutionName(element))
           : graph.addConstantNull(compiler);
       List<HInstruction> inputs = <HInstruction>[
         expression,
         isFieldName,
         representations,
         asFieldName
       ];
-      pushInvokeStatic(node, helper, inputs, typeMask: backend.boolType);
+      pushInvokeStatic(helper, inputs,
+          typeMask: backend.boolType, location: node);
       HInstruction call = pop();
       return new HIs.compound(type, expression, call, backend.boolType);
     } else {
       if (backend.hasDirectCheckFor(type)) {
         return new HIs.direct(type, expression, backend.boolType);
       }
       // The interceptor is not always needed.  It is removed by optimization
       // when the receiver type or tested type permit.
       return new HIs.raw(
           type, expression, invokeInterceptor(expression), backend.boolType);
@@ skipping 230 matching lines @@
           js.js.parseForeignJS(name), backend.dynamicType, <HInstruction>[],
           nativeBehavior: native.NativeBehavior.DEPENDS_OTHER));
     } else {
       // Call a helper method from the isolate library. The isolate
       // library uses its own isolate structure, that encapsulates
       // Leg's isolate.
       Element element = helpers.currentIsolate;
       if (element == null) {
         reporter.internalError(node, 'Isolate library and compiler mismatch.');
       }
-      pushInvokeStatic(null, element, [], typeMask: backend.dynamicType);
+      pushInvokeStatic(element, [], typeMask: backend.dynamicType);
     }
   }
 
   void handleForeignJsGetFlag(ast.Send node) {
     List<ast.Node> arguments = node.arguments.toList();
     ast.Node argument;
     switch (arguments.length) {
       case 0:
         reporter.reportErrorMessage(node, MessageKind.GENERIC,
             {'text': 'Error: Expected one argument to JS_GET_FLAG.'});
@@ skipping 174 matching lines @@
       push(new HInvokeClosure(new Selector.callClosure(0),
           <HInstruction>[pop()], backend.dynamicType));
     } else {
       // Call a helper method from the isolate library.
       Element element = helpers.callInIsolate;
       if (element == null) {
         reporter.internalError(node, 'Isolate library and compiler mismatch.');
       }
       List<HInstruction> inputs = <HInstruction>[];
       addGenericSendArgumentsToList(link, inputs);
-      pushInvokeStatic(node, element, inputs, typeMask: backend.dynamicType);
+      pushInvokeStatic(element, inputs,
+          typeMask: backend.dynamicType, location: node);
     }
   }
 
   FunctionSignature handleForeignRawFunctionRef(ast.Send node, String name) {
     if (node.arguments.isEmpty || !node.arguments.tail.isEmpty) {
       reporter.internalError(
           node.argumentsNode, '"$name" requires exactly one argument.');
     }
     ast.Node closure = node.arguments.head;
     Element element = elements[closure];
@@ skipping 138 matching lines @@
           constantSystem.createString(new ast.DartString.literal(argumentName));
       argumentNames.add(graph.addConstant(argumentNameConstant, compiler));
     }
     var argumentNamesInstruction = buildLiteralList(argumentNames);
     add(argumentNamesInstruction);
 
     ConstantValue kindConstant =
         constantSystem.createInt(selector.invocationMirrorKind);
 
     pushInvokeStatic(
-        null,
         createInvocationMirror,
         [
           graph.addConstant(nameConstant, compiler),
           graph.addConstantStringFromName(internalName, compiler),
           graph.addConstant(kindConstant, compiler),
           argumentsInstruction,
           argumentNamesInstruction
         ],
         typeMask: backend.dynamicType);
 
@@ skipping 186 matching lines @@
     if (!backend.classNeedsRti(type.element) || type.treatAsRaw) {
       return newObject;
     }
     List<HInstruction> inputs = <HInstruction>[];
     type = localsHandler.substInContext(type);
     type.typeArguments.forEach((DartType argument) {
       inputs.add(typeBuilder.analyzeTypeArgument(argument, sourceElement));
     });
     // TODO(15489): Register at codegen.
     registry?.registerInstantiation(type);
-    return callSetRuntimeTypeInfoWithTypeArguments(
-        type.element, inputs, newObject);
-  }
-
-  HInstruction callSetRuntimeTypeInfoWithTypeArguments(ClassElement element,
-      List<HInstruction> rtiInputs, HInstruction newObject) {
-    if (!backend.classNeedsRti(element)) {
-      return newObject;
-    }
-
-    HInstruction typeInfo = new HTypeInfoExpression(
-        TypeInfoExpressionKind.INSTANCE,
-        element.thisType,
-        rtiInputs,
-        backend.dynamicType);
-    add(typeInfo);
-    return callSetRuntimeTypeInfo(typeInfo, newObject);
-  }
-
-  HInstruction callSetRuntimeTypeInfo(
-      HInstruction typeInfo, HInstruction newObject) {
-    // Set the runtime type information on the object.
-    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.
-    assert(invariant(CURRENT_ELEMENT_SPANNABLE,
-        stack.last is HInvokeStatic || stack.last == newObject,
-        message: "Unexpected `stack.last`: Found ${stack.last}, "
-            "expected ${newObject} or an HInvokeStatic. "
-            "State: typeInfo=$typeInfo, stack=$stack."));
-    stack.last.instructionType = newObject.instructionType;
-    return pop();
+    return callSetRuntimeTypeInfoWithTypeArguments(type, inputs, newObject);
   }
 
   void handleNewSend(ast.NewExpression node) {
     ast.Send send = node.send;
     generateIsDeferredLoadedCheckOfSend(send);
 
     bool isFixedList = false;
     bool isFixedListConstructorCall =
         Elements.isFixedListConstructorCall(elements[send], send, compiler);
     bool isGrowableListConstructorCall =
@@ skipping 158 matching lines @@
             throwBehavior: native.NativeThrowBehavior.MAY));
       }
     } else if (isGrowableListConstructorCall) {
       push(buildLiteralList(<HInstruction>[]));
       stack.last.instructionType = elementType;
     } else {
       SourceInformation sourceInformation =
           sourceInformationBuilder.buildNew(send);
       potentiallyAddTypeArguments(inputs, cls, expectedType);
       addInlinedInstantiation(expectedType);
-      pushInvokeStatic(node, constructor.declaration, inputs,
+      pushInvokeStatic(constructor.declaration, inputs,
           typeMask: elementType,
           instanceType: expectedType,
-          sourceInformation: sourceInformation);
+          sourceInformation: sourceInformation,
+          location: node);
       removeInlinedInstantiation(expectedType);
     }
     HInstruction newInstance = stack.last;
     if (isFixedList) {
       // Overwrite the element type, in case the allocation site has
       // been inlined.
       newInstance.instructionType = elementType;
       graph.allocatedFixedLists?.add(newInstance);
     }
 
@@ skipping 93 matching lines @@
   void generateStaticFunctionInvoke(
       ast.Send node, FunctionElement function, CallStructure callStructure) {
     List<HInstruction> inputs = makeStaticArgumentList(
         callStructure, node.arguments, function.implementation);
 
     if (function == compiler.commonElements.identicalFunction) {
       pushWithPosition(
           new HIdentity(inputs[0], inputs[1], null, backend.boolType), node);
       return;
     } else {
-      pushInvokeStatic(node, function, inputs,
+      pushInvokeStatic(function, inputs,
           sourceInformation:
-              sourceInformationBuilder.buildCall(node, node.selector));
+              sourceInformationBuilder.buildCall(node, node.selector),
+          location: node);
     }
   }
 
   /// Generate an invocation to a static or top level function with the wrong
   /// number of arguments.
   void generateStaticFunctionIncompatibleInvoke(
       ast.Send node, Element element) {
     generateWrongArgumentCountError(node, element, node.arguments);
   }
 
@@ skipping 178 matching lines @@
       ast.Send node, TypeVariableType typeVariable) {
     // GENERIC_METHODS: This provides thin support for method type variables
     // by treating them as malformed when evaluated as a literal. For full
     // support of generic methods this must be revised.
     if (typeVariable is MethodTypeVariableType) {
       generateTypeError(node, "Method type variables are not reified");
     } else {
       DartType type = localsHandler.substInContext(typeVariable);
       HInstruction value = typeBuilder.analyzeTypeArgument(type, sourceElement,
           sourceInformation: sourceInformationBuilder.buildGet(node));
-      pushInvokeStatic(node, helpers.runtimeTypeToString, [value],
-          typeMask: backend.stringType);
-      pushInvokeStatic(node, helpers.createRuntimeType, [pop()]);
+      pushInvokeStatic(helpers.runtimeTypeToString, [value],
+          typeMask: backend.stringType, location: node);
+      pushInvokeStatic(helpers.createRuntimeType, [pop()], location: node);
     }
   }
 
   /// 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 16 matching lines @@
     internalError(node, "Unexpected visitGetterSend");
   }
 
   // TODO(antonm): migrate rest of SsaFromAstMixin to internalError.
   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]);
+    pushInvokeStatic(helper, [errorMessage], location: node);
   }
 
   void generateRuntimeError(ast.Node node, String message) {
     generateError(node, message, helpers.throwRuntimeError);
   }
 
   void generateTypeError(ast.Node node, String message) {
     generateError(node, message, helpers.throwTypeError);
   }
 
@@ skipping 29 matching lines @@
       for (String name in existingArguments) {
         HInstruction nameConstant =
             graph.addConstantString(new ast.DartString.literal(name), compiler);
         existingNames.add(nameConstant);
       }
       existingNamesList = buildLiteralList(existingNames);
       add(existingNamesList);
     } else {
       existingNamesList = graph.addConstantNull(compiler);
     }
-    pushInvokeStatic(
-        diagnosticNode, helper, [receiver, name, arguments, existingNamesList],
-        sourceInformation: sourceInformation);
+    pushInvokeStatic(helper, [receiver, name, arguments, existingNamesList],
+        sourceInformation: sourceInformation, location: diagnosticNode);
   }
 
   /**
    * Generate code to throw a [NoSuchMethodError] exception for calling a
    * method with a wrong number of arguments or mismatching named optional
    * arguments.
    */
   void generateWrongArgumentCountError(ast.Node diagnosticNode,
       FunctionElement function, Link<ast.Node> argumentNodes) {
     List<String> existingArguments = <String>[];
@@ skipping 220 matching lines @@
       var args = new List.filled(arguments.length, '#').join(',');
       code = element.isConstructor ? "new #($args)" : "#($args)";
     }
     js.Template codeTemplate = js.js.parseForeignJS(code);
     nativeBehavior.codeTemplate = codeTemplate;
 
     return new HForeignCode(codeTemplate, backend.dynamicType, inputs,
         nativeBehavior: nativeBehavior)..sourceInformation = sourceInformation;
   }
 
-  void pushInvokeStatic(
-      ast.Node location, MethodElement element, List<HInstruction> arguments,
+  void pushInvokeStatic(MethodElement element, List<HInstruction> arguments,
       {TypeMask typeMask,
       InterfaceType instanceType,
-      SourceInformation sourceInformation}) {
+      SourceInformation sourceInformation,
+      ast.Node location}) {
     assert(element.isDeclaration);
     // TODO(johnniwinther): Use [sourceInformation] instead of [location].
     if (tryInlineMethod(element, null, null, arguments, location,
         instanceType: instanceType)) {
       return;
     }
 
     if (typeMask == null) {
       typeMask =
           TypeMaskFactory.inferredReturnTypeForElement(element, compiler);
@@ skipping 970 matching lines @@
     ClassElement targetClass = targetConstructor.enclosingClass;
     if (backend.classNeedsRti(targetClass)) {
       ClassElement cls = redirectingConstructor.enclosingClass;
       InterfaceType targetType =
           redirectingConstructor.computeEffectiveTargetType(cls.thisType);
       targetType = localsHandler.substInContext(targetType);
       targetType.typeArguments.forEach((DartType argument) {
         inputs.add(typeBuilder.analyzeTypeArgument(argument, sourceElement));
       });
     }
-    pushInvokeStatic(node, targetConstructor.declaration, inputs);
+    pushInvokeStatic(targetConstructor.declaration, inputs, location: node);
     HInstruction value = pop();
     emitReturn(value, node);
   }
 
   /// Returns true if the [type] is a valid return type for an asynchronous
   /// function.
   ///
   /// Asynchronous functions return a `Future`, and a valid return is thus
   /// either dynamic, Object, or Future.
   ///
@@ skipping 93 matching lines @@
     if (!backend.classNeedsRti(type.element) || type.treatAsRaw) {
       return object;
     }
     List<HInstruction> arguments = <HInstruction>[];
     for (DartType argument in type.typeArguments) {
       arguments.add(typeBuilder.analyzeTypeArgument(argument, sourceElement));
     }
     // TODO(15489): Register at codegen.
     registry?.registerInstantiation(type);
     return callSetRuntimeTypeInfoWithTypeArguments(
-        type.element, arguments, object);
+        // TODO(efortuna): this was type.element.thisType. Is this equivalent?
+        type,
+        arguments,
+        object);
   }
 
   visitLiteralList(ast.LiteralList node) {
     HInstruction instruction;
 
     if (node.isConst) {
       instruction = addConstant(node);
     } else {
       List<HInstruction> inputs = <HInstruction>[];
       for (Link<ast.Node> link = node.elements.nodes;
@@ skipping 96 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, helpers.streamIteratorConstructor,
-        [expression, graph.addConstantNull(compiler)]);
+    pushInvokeStatic(helpers.streamIteratorConstructor,
+        [expression, graph.addConstantNull(compiler)],
+        location: node);
     streamIterator = pop();
 
     void buildInitializer() {}
 
     HInstruction buildCondition() {
       Selector selector = Selectors.moveNext;
       TypeMask mask = elementInferenceResults.typeOfIteratorMoveNext(node);
       pushInvokeDynamic(node, selector, mask, [streamIterator]);
       HInstruction future = pop();
       push(new HAwait(
@@ skipping 152 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, helpers.checkConcurrentModificationError, [pop(), array]);
+      pushInvokeStatic(helpers.checkConcurrentModificationError, [pop(), array],
+          location: node);
       pop();
     }
 
     void buildInitializer() {
       visit(node.expression);
       array = pop();
       isFixed = isFixedLength(array.instructionType, compiler);
       localsHandler.updateLocal(
           indexVariable, graph.addConstantInt(0, compiler));
       originalLength = buildGetLength();
@@ skipping 163 matching lines @@
     // type inference might discover a more specific type, or find nothing (in
     // dart2js unit tests).
     TypeMask mapType = new TypeMask.nonNullSubtype(
         helpers.mapLiteralClass, compiler.closedWorld);
     TypeMask returnTypeMask =
         TypeMaskFactory.inferredReturnTypeForElement(constructor, compiler);
     TypeMask instructionType =
         mapType.intersection(returnTypeMask, compiler.closedWorld);
 
     addInlinedInstantiation(expectedType);
-    pushInvokeStatic(node, constructor, inputs,
-        typeMask: instructionType, instanceType: expectedType);
+    pushInvokeStatic(constructor, inputs,
+        typeMask: instructionType, instanceType: expectedType, location: node);
     removeInlinedInstantiation(expectedType);
   }
 
   visitLiteralMapEntry(ast.LiteralMapEntry node) {
     visit(node.value);
     visit(node.key);
   }
 
   visitNamedArgument(ast.NamedArgument node) {
     visit(node.expression);
@@ skipping 278 matching lines @@
         // An HSwitch has n inputs and n+1 successors, the last being the
         // default case.
         expressionEnd.addSuccessor(block);
         hasDefault = true;
       }
       open(block);
       localsHandler = new LocalsHandler.from(savedLocals);
       buildSwitchCase(switchCase);
       if (!isAborted()) {
         if (caseIterator.hasNext && isReachable) {
-          pushInvokeStatic(switchCase, helpers.fallThroughError, []);
+          pushInvokeStatic(helpers.fallThroughError, [], location: switchCase);
           HInstruction error = pop();
           closeAndGotoExit(new HThrow(error, error.sourceInformation));
         } else if (!isDefaultCase(switchCase)) {
           // If there is no default, we will add one later to avoid
           // the critical edge. So we generate a break statement to make
           // sure the last case does not fall through to the default case.
           jumpHandler.generateBreak();
         }
       }
       statements.add(
@@ skipping 199 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, helpers.exceptionUnwrapper, [exception]);
+      pushInvokeStatic(helpers.exceptionUnwrapper, [exception], location: node);
       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 24 matching lines @@
       void visitThen() {
         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, helpers.traceFromException, [exception]);
+          pushInvokeStatic(helpers.traceFromException, [exception],
+              location: trace);
           HInstruction traceInstruction = pop();
           LocalVariableElement traceVariable = elements[trace];
           localsHandler.updateLocal(traceVariable, traceInstruction);
         }
         visit(catchBlock);
       }
 
       void visitElse() {
         if (link.isEmpty) {
           closeAndGotoExit(new HThrow(exception, exception.sourceInformation,
@@ skipping 459 matching lines @@
       this.oldReturnLocal,
       this.oldReturnType,
       this.oldResolvedAst,
       this.oldStack,
       this.oldLocalsHandler,
       this.inTryStatement,
       this.allFunctionsCalledOnce,
       this.oldElementInferenceResults)
       : super(function);
 }