Make source information mandatory for building send-like node in CPS

pkg/compiler/lib/src/cps_ir/cps_ir_builder_task.dart

 // Copyright (c) 2013, 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.
 
 library dart2js.ir_builder_task;
 
 import '../closure.dart' as closure;
 import '../common.dart';
 import '../common/names.dart' show
     Identifiers,
@@ skipping 1136 matching lines @@
         new Selector.callConstructor(constructor.memberName, 1),
         <ir.Primitive>[stream, dummyTypeArgument],
         sourceInformationBuilder.buildGeneric(node)));
 
     ir.Node buildTryBody(IrBuilder builder) {
       ir.Node buildLoopCondition(IrBuilder builder) {
         ir.Primitive moveNext = builder.buildDynamicInvocation(
             iterator,
             Selectors.moveNext,
             elements.getMoveNextTypeMask(node),
-            <ir.Primitive>[]);
+            <ir.Primitive>[],
+            sourceInformationBuilder.buildForInMoveNext(node));
         return builder.addPrimitive(new ir.Await(moveNext));
       }
 
       ir.Node buildLoopBody(IrBuilder builder) {
         return withBuilder(builder, () {
           ir.Primitive current = irBuilder.buildDynamicInvocation(
               iterator,
               Selectors.current,
               elements.getCurrentTypeMask(node),
-              <ir.Primitive>[]);
+              <ir.Primitive>[],
+              sourceInformationBuilder.buildForInCurrent(node));
           Element variable = elements.getForInVariable(node);
+          SourceInformation sourceInformation =
+              sourceInformationBuilder.buildForInSet(node);
           if (Elements.isLocal(variable)) {
             if (node.declaredIdentifier.asVariableDefinitions() != null) {
               irBuilder.declareLocalVariable(variable);
             }
-            irBuilder.buildLocalVariableSet(variable, current);
+            irBuilder.buildLocalVariableSet(
+                variable, current, sourceInformation);
           } else if (Elements.isError(variable) ||
                      Elements.isMalformed(variable)) {
             Selector selector =
                 new Selector.setter(new Name(variable.name, variable.library));
             List<ir.Primitive> args = <ir.Primitive>[current];
             // Note the comparison below.  It can be the case that an element
             // isError and isMalformed.
             if (Elements.isError(variable)) {
-              irBuilder.buildStaticNoSuchMethod(selector, args);
+              irBuilder.buildStaticNoSuchMethod(
+                  selector, args, sourceInformation);
             } else {
-              irBuilder.buildErroneousInvocation(variable, selector, args);
+              irBuilder.buildErroneousInvocation(
+                  variable, selector, args, sourceInformation);
             }
           } else if (Elements.isStaticOrTopLevel(variable)) {
             if (variable.isField) {
               irBuilder.addPrimitive(new ir.SetStatic(variable, current));
             } else {
-              irBuilder.buildStaticSetterSet(variable, current);
+              irBuilder.buildStaticSetterSet(
+                  variable, current, sourceInformation);
             }
           } else {
             ir.Primitive receiver = irBuilder.buildThis();
             ast.Node identifier = node.declaredIdentifier;
             irBuilder.buildDynamicSet(
                 receiver,
                 elements.getSelector(identifier),
                 elements.getTypeMask(identifier),
-                current);
+                current,
+                sourceInformation);
           }
           visit(node.body);
         });
       }
 
       builder.buildWhile(
           buildCondition: buildLoopCondition,
           buildBody: buildLoopBody,
           target: elements.getTargetDefinition(node),
           closureScope: getClosureScopeForNode(node));
     }
 
     ir.Node buildFinallyBody(IrBuilder builder) {
       ir.Primitive cancellation = builder.buildDynamicInvocation(
           iterator,
           Selectors.cancel,
           backend.dynamicType,
           <ir.Primitive>[],
-          sourceInformation: sourceInformationBuilder.buildGeneric(node));
+          sourceInformationBuilder.buildGeneric(node));
       return builder.addPrimitive(new ir.Await(cancellation));
     }
 
     irBuilder.buildTryFinally(new TryStatementInfo(), buildTryBody,
         buildFinallyBody);
   }
 
   visitAwait(ast.Await node) {
     assert(irBuilder.isOpen);
     ir.Primitive value = visit(node.expression);
@@ skipping 15 matching lines @@
         identifier.asVariableDefinitions();
     Element variableElement = elements.getForInVariable(node);
     Selector selector = elements.getSelector(identifier);
 
     irBuilder.buildForIn(
         buildExpression: subbuild(node.expression),
         buildVariableDeclaration: subbuild(variableDeclaration),
         variableElement: variableElement,
         variableSelector: selector,
         variableMask: elements.getTypeMask(identifier),
+        variableSetSourceInformation:
+          sourceInformationBuilder.buildForInSet(node),
         currentMask: elements.getCurrentTypeMask(node),
+        currentSourceInformation:
+          sourceInformationBuilder.buildForInCurrent(node),
         moveNextMask: elements.getMoveNextTypeMask(node),
+        moveNextSourceInformation:
+          sourceInformationBuilder.buildForInMoveNext(node),
         iteratorMask: elements.getIteratorTypeMask(node),
+        iteratorSourceInformation:
+          sourceInformationBuilder.buildForInIterator(node),
         buildBody: subbuild(node.body),
         target: elements.getTargetDefinition(node),
         closureScope: getClosureScopeForNode(node));
   }
 
   /// If compiling with trusted type annotations, assumes that [value] is
   /// now known to be `null` or an instance of [type].
   ///
   /// This is also where we should add type checks in checked mode, but this
   /// is not supported yet.
@@ skipping 44 matching lines @@
       if (nativeBody != null) {
         ast.LiteralString jsCode = nativeBody.asLiteralString();
         String javaScriptCode = jsCode.dartString.slowToString();
         assert(invariant(nativeBody,
             !nativeRedirectionRegExp.hasMatch(javaScriptCode),
           message: "Deprecated syntax, use @JSName('name') instead."));
         assert(invariant(nativeBody,
             function.functionSignature.parameterCount == 0,
             message: 'native "..." syntax is restricted to '
               'functions with zero parameters.'));
-        irBuilder.buildNativeFunctionBody(function, javaScriptCode);
+        irBuilder.buildNativeFunctionBody(function, javaScriptCode,
+            sourceInformationBuilder.buildForeignCode(node));
       } else {
         String name = backend.getFixedBackendName(function);
         irBuilder.buildRedirectingNativeFunctionBody(function, name, source);
       }
     } else {
       irBuilder.buildReturn(
           value: build(node.expression),
           sourceInformation: source);
     }
   }
@@ skipping 277 matching lines @@
         stackTraceVariable = elements[catchClause.trace];
       }
       DartType type;
       if (catchClause.onKeyword != null) {
         type = elements.getType(catchClause.type);
       }
       catchClauseInfos.add(new CatchClauseInfo(
           type: type,
           exceptionVariable: exceptionVariable,
           stackTraceVariable: stackTraceVariable,
-          buildCatchBlock: subbuild(catchClause.block)));
+          buildCatchBlock: subbuild(catchClause.block),
+          sourceInformation: sourceInformationBuilder.buildCatch(catchClause)));
     }
 
     assert(!node.catchBlocks.isEmpty || node.finallyBlock != null);
     if (!node.catchBlocks.isEmpty && node.finallyBlock != null) {
       // Try/catch/finally is encoded in terms of try/catch and try/finally:
       //
       // try tryBlock catch (ex, st) catchBlock finally finallyBlock
       // ==>
       // try { try tryBlock catch (ex, st) catchBlock } finally finallyBlock
       irBuilder.buildTryFinally(tryStatements[node.finallyBlock],
@@ skipping 107 matching lines @@
       return translateConstant(node);
     }
 
     InterfaceType type = elements.getType(node);
 
     if (node.entries.nodes.isEmpty) {
       if (type.treatAsRaw) {
         return irBuilder.buildStaticFunctionInvocation(
             helpers.mapLiteralUntypedEmptyMaker,
             <ir.Primitive>[],
-            sourceInformation: sourceInformationBuilder.buildNew(node));
+            sourceInformationBuilder.buildNew(node));
       } else {
         ConstructorElement constructor = helpers.mapLiteralConstructorEmpty;
         return irBuilder.buildConstructorInvocation(
             constructor.effectiveTarget,
             CallStructure.NO_ARGS,
             constructor.computeEffectiveTargetType(type),
             <ir.Primitive>[],
             sourceInformationBuilder.buildNew(node));
       }
     }
 
     List<ir.Primitive> keysAndValues = <ir.Primitive>[];
     for (ast.LiteralMapEntry entry in node.entries.nodes.toList()) {
       keysAndValues.add(visit(entry.key));
       keysAndValues.add(visit(entry.value));
     }
     ir.Primitive keysAndValuesList =
         irBuilder.buildListLiteral(null, keysAndValues);
 
     if (type.treatAsRaw) {
       return irBuilder.buildStaticFunctionInvocation(
           helpers.mapLiteralUntypedMaker,
           <ir.Primitive>[keysAndValuesList],
-          sourceInformation: sourceInformationBuilder.buildNew(node));
+          sourceInformationBuilder.buildNew(node));
     } else {
       ConstructorElement constructor = helpers.mapLiteralConstructor;
       return irBuilder.buildConstructorInvocation(
           constructor.effectiveTarget,
           CallStructure.ONE_ARG,
           constructor.computeEffectiveTargetType(type),
           <ir.Primitive>[keysAndValuesList],
           sourceInformationBuilder.buildNew(node));
     }
   }
@@ skipping 53 matching lines @@
   ir.Primitive buildCheckDeferredIsLoaded(PrefixElement prefix, ast.Send node) {
     SourceInformation sourceInformation =
         sourceInformationBuilder.buildCall(node, node.selector);
     ir.Primitive name = irBuilder.buildStringConstant(
         compiler.deferredLoadTask.getImportDeferName(node, prefix));
     ir.Primitive uri =
         irBuilder.buildStringConstant('${prefix.deferredImport.uri}');
     return irBuilder.buildStaticFunctionInvocation(
         helpers.checkDeferredIsLoaded,
         <ir.Primitive>[name, uri],
-        sourceInformation: sourceInformation);
+        sourceInformation);
   }
 
   ir.Primitive visitNamedArgument(ast.NamedArgument node) {
     assert(irBuilder.isOpen);
     return visit(node.expression);
   }
 
   @override
   ir.Primitive visitExpressionInvoke(ast.Send node,
                                      ast.Node expression,
                                      ast.NodeList argumentsNode,
                                      CallStructure callStructure, _) {
     ir.Primitive receiver = visit(expression);
     List<ir.Primitive> arguments = argumentsNode.nodes.mapToList(visit);
     callStructure = normalizeDynamicArguments(callStructure, arguments);
     return irBuilder.buildCallInvocation(receiver, callStructure, arguments,
-        sourceInformation:
-            sourceInformationBuilder.buildCall(node, argumentsNode));
+        sourceInformationBuilder.buildCall(node, argumentsNode));
   }
 
   /// Returns `true` if [node] is a super call.
   // TODO(johnniwinther): Remove the need for this.
   bool isSuperCall(ast.Send node) {
     return node != null && node.receiver != null && node.receiver.isSuper();
   }
 
   @override
   ir.Primitive handleConstantGet(
@@ skipping 71 matching lines @@
       MethodElement function,
       _) {
     return irBuilder.addPrimitive(new ir.GetStatic(function, isFinal: true));
   }
 
   @override
   ir.Primitive handleStaticGetterGet(
       ast.Send node,
       FunctionElement getter,
       _) {
-    return buildStaticGetterGet(getter, node);
+   return buildStaticGetterGet(
+       getter, node, sourceInformationBuilder.buildGet(node));
   }
 
   /// Create a getter invocation of the static getter [getter]. This also
   /// handles the special case where [getter] is the `loadLibrary`
   /// pseudo-function on library prefixes of deferred imports.
-  ir.Primitive buildStaticGetterGet(MethodElement getter, ast.Send node) {
-    SourceInformation sourceInformation =
-        sourceInformationBuilder.buildGet(node);
+  ir.Primitive buildStaticGetterGet(
+      MethodElement getter,
+      ast.Send node,
+      SourceInformation sourceInformation) {
     if (getter.isDeferredLoaderGetter) {
       PrefixElement prefix = getter.enclosingElement;
       ir.Primitive loadId = irBuilder.buildStringConstant(
           compiler.deferredLoadTask.getImportDeferName(node, prefix));
       return irBuilder.buildStaticFunctionInvocation(
           compiler.loadLibraryFunction,
           <ir.Primitive>[loadId],
-          sourceInformation: sourceInformation);
+          sourceInformation);
     } else {
       return irBuilder.buildStaticGetterGet(getter, sourceInformation);
     }
   }
 
   @override
   ir.Primitive visitSuperFieldGet(
       ast.Send node,
       FieldElement field,
       _) {
-    return irBuilder.buildSuperFieldGet(field);
+    return irBuilder.buildSuperFieldGet(
+        field, sourceInformationBuilder.buildGet(node));
   }
 
   @override
   ir.Primitive visitSuperGetterGet(
       ast.Send node,
       FunctionElement getter,
       _) {
     return irBuilder.buildSuperGetterGet(
         getter, sourceInformationBuilder.buildGet(node));
   }
 
   @override
   ir.Primitive visitSuperMethodGet(
       ast.Send node,
       MethodElement method,
       _) {
-    return irBuilder.buildSuperMethodGet(method);
+    return irBuilder.buildSuperMethodGet(
+        method, sourceInformationBuilder.buildGet(node));
   }
 
   @override
   ir.Primitive visitUnresolvedSuperGet(
       ast.Send node,
       Element element, _) {
     return buildSuperNoSuchMethod(
-        elements.getSelector(node), elements.getTypeMask(node), []);
+        elements.getSelector(node), elements.getTypeMask(node), [],
+        sourceInformationBuilder.buildGet(node));
   }
 
   @override
   ir.Primitive visitUnresolvedSuperSet(
       ast.Send node,
       Element element,
       ast.Node rhs, _) {
     return buildSuperNoSuchMethod(
-        elements.getSelector(node), elements.getTypeMask(node), [visit(rhs)]);
+        elements.getSelector(node), elements.getTypeMask(node), [visit(rhs)],
+        sourceInformationBuilder.buildAssignment(node));
   }
 
   @override
   ir.Primitive visitThisGet(ast.Identifier node, _) {
     if (irBuilder.state.thisParameter == null) {
       // TODO(asgerf,johnniwinther): Should be in a visitInvalidThis method.
       // 'this' in static context. Just translate to null.
       assert(compiler.compilationFailed);
       return irBuilder.buildNullConstant();
     }
@@ skipping 44 matching lines @@
     return translateLogicalOperator(left, right, isLazyOr: true);
   }
 
   @override
   ir.Primitive visitAs(
       ast.Send node,
       ast.Node expression,
       DartType type,
       _) {
     ir.Primitive receiver = visit(expression);
-    return irBuilder.buildTypeOperator(receiver, type, isTypeTest: false);
+    return irBuilder.buildTypeOperator(
+        receiver,
+        type,
+        sourceInformationBuilder.buildAs(node),
+        isTypeTest: false);
   }
 
   @override
   ir.Primitive visitIs(
       ast.Send node,
       ast.Node expression,
       DartType type,
       _) {
     ir.Primitive value = visit(expression);
-    return irBuilder.buildTypeOperator(value, type, isTypeTest: true);
+    return irBuilder.buildTypeOperator(
+        value,
+        type,
+        sourceInformationBuilder.buildIs(node),
+        isTypeTest: true);
   }
 
   @override
   ir.Primitive visitIsNot(ast.Send node,
                           ast.Node expression, DartType type, _) {
     ir.Primitive value = visit(expression);
     ir.Primitive check = irBuilder.buildTypeOperator(
-        value, type, isTypeTest: true);
+        value,
+        type,
+        sourceInformationBuilder.buildIs(node),
+        isTypeTest: true);
     return irBuilder.buildNegation(check);
   }
 
   ir.Primitive translateBinary(ast.Send node,
                                ast.Node left,
                                op.BinaryOperator operator,
                                ast.Node right) {
     ir.Primitive receiver = visit(left);
     Selector selector = new Selector.binaryOperator(operator.selectorName);
     List<ir.Primitive> arguments = <ir.Primitive>[visit(right)];
     CallStructure callStructure =
         normalizeDynamicArguments(selector.callStructure, arguments);
     return irBuilder.buildDynamicInvocation(
         receiver,
         new Selector(selector.kind, selector.memberName, callStructure),
         elements.getTypeMask(node),
         arguments,
-        sourceInformation:
-            sourceInformationBuilder.buildCall(node, node.selector));
+        sourceInformationBuilder.buildCall(node, node.selector));
   }
 
   @override
   ir.Primitive visitBinary(ast.Send node,
                            ast.Node left,
                            op.BinaryOperator operator,
                            ast.Node right, _) {
     return translateBinary(node, left, operator, right);
   }
 
   @override
   ir.Primitive visitIndex(ast.Send node,
                           ast.Node receiver,
                           ast.Node index, _) {
     ir.Primitive target = visit(receiver);
     Selector selector = new Selector.index();
     List<ir.Primitive> arguments = <ir.Primitive>[visit(index)];
     CallStructure callStructure =
         normalizeDynamicArguments(selector.callStructure, arguments);
     return irBuilder.buildDynamicInvocation(
         target,
         new Selector(selector.kind, selector.memberName, callStructure),
         elements.getTypeMask(node),
         arguments,
-        sourceInformation:
-            sourceInformationBuilder.buildCall(receiver, node.selector));
+        sourceInformationBuilder.buildCall(receiver, node.selector));
   }
 
   ir.Primitive translateSuperBinary(FunctionElement function,
                                     op.BinaryOperator operator,
-                                    ast.Node argument) {
+                                    ast.Node argument,
+                                    SourceInformation sourceInformation) {
     List<ir.Primitive> arguments = <ir.Primitive>[visit(argument)];
     return irBuilder.buildSuperMethodInvocation(function,
-        CallStructure.ONE_ARG, arguments);
+        CallStructure.ONE_ARG, arguments, sourceInformation);
   }
 
   @override
   ir.Primitive visitSuperBinary(
       ast.Send node,
       FunctionElement function,
       op.BinaryOperator operator,
       ast.Node argument,
       _) {
-    return translateSuperBinary(function, operator, argument);
+    return translateSuperBinary(function, operator, argument,
+        sourceInformationBuilder.buildBinary(node));
   }
 
   @override
   ir.Primitive visitSuperIndex(
       ast.Send node,
       FunctionElement function,
       ast.Node index,
       _) {
-    return irBuilder.buildSuperIndex(function, visit(index));
+    return irBuilder.buildSuperIndex(function, visit(index),
+        sourceInformationBuilder.buildIndex(node));
   }
 
   @override
   ir.Primitive visitEquals(
       ast.Send node,
       ast.Node left,
       ast.Node right,
       _) {
     return translateBinary(node, left, op.BinaryOperator.EQ, right);
   }
 
   @override
   ir.Primitive visitSuperEquals(
       ast.Send node,
       FunctionElement function,
       ast.Node argument,
       _) {
-    return translateSuperBinary(function, op.BinaryOperator.EQ, argument);
+    return translateSuperBinary(function, op.BinaryOperator.EQ, argument,
+        sourceInformationBuilder.buildBinary(node));
   }
 
   @override
   ir.Primitive visitNot(
       ast.Send node,
       ast.Node expression,
       _) {
     return irBuilder.buildNegation(visit(expression));
   }
 
   @override
   ir.Primitive visitNotEquals(
       ast.Send node,
       ast.Node left,
       ast.Node right,
       _) {
     return irBuilder.buildNegation(
         translateBinary(node, left, op.BinaryOperator.NOT_EQ, right));
   }
 
   @override
   ir.Primitive visitSuperNotEquals(
       ast.Send node,
       FunctionElement function,
       ast.Node argument,
       _) {
     return irBuilder.buildNegation(
-        translateSuperBinary(function, op.BinaryOperator.NOT_EQ, argument));
+        translateSuperBinary(function, op.BinaryOperator.NOT_EQ, argument,
+            sourceInformationBuilder.buildBinary(node)));
   }
 
   @override
   ir.Primitive visitUnary(ast.Send node,
                           op.UnaryOperator operator, ast.Node expression, _) {
     // TODO(johnniwinther): Clean up the creation of selectors.
     Selector selector = operator.selector;
     ir.Primitive receiver = translateReceiver(expression);
     return irBuilder.buildDynamicInvocation(
         receiver, selector, elements.getTypeMask(node), const [],
-        sourceInformation: sourceInformationBuilder.buildCall(
-            expression, node));
+        sourceInformationBuilder.buildCall(expression, node));
   }
 
   @override
   ir.Primitive visitSuperUnary(
       ast.Send node,
       op.UnaryOperator operator,
       FunctionElement function,
       _) {
     return irBuilder.buildSuperMethodInvocation(
-        function, CallStructure.NO_ARGS, const []);
+        function, CallStructure.NO_ARGS, const [],
+        sourceInformationBuilder.buildCall(node, node));
   }
 
   // TODO(johnniwinther): Handle this in the [IrBuilder] to ensure the correct
   // semantic correlation between arguments and invocation.
   CallStructure translateDynamicArguments(ast.NodeList nodeList,
                                           CallStructure callStructure,
                                           List<ir.Primitive> arguments) {
     assert(arguments.isEmpty);
     for (ast.Node node in nodeList) arguments.add(visit(node));
     return normalizeDynamicArguments(callStructure, arguments);
@@ skipping 10 matching lines @@
     return normalizeStaticArguments(callStructure, element, arguments);
   }
 
   ir.Primitive translateCallInvoke(ir.Primitive target,
                                    ast.NodeList argumentsNode,
                                    CallStructure callStructure,
                                    SourceInformation sourceInformation) {
     List<ir.Primitive> arguments = <ir.Primitive>[];
     callStructure =
         translateDynamicArguments(argumentsNode, callStructure, arguments);
-    return irBuilder.buildCallInvocation(target, callStructure, arguments,
-        sourceInformation: sourceInformation);
+    return irBuilder.buildCallInvocation(
+        target, callStructure, arguments, sourceInformation);
   }
 
   @override
   ir.Primitive handleConstantInvoke(
       ast.Send node,
       ConstantExpression constant,
       ast.NodeList arguments,
       CallStructure callStructure,
       _) {
     ir.Primitive target = buildConstantExpression(constant,
@@ skipping 77 matching lines @@
       _) {
     ir.Primitive target = translateReceiver(receiver);
     List<ir.Primitive> arguments = <ir.Primitive>[];
     CallStructure callStructure = translateDynamicArguments(
         argumentsNode, selector.callStructure, arguments);
     return irBuilder.buildDynamicInvocation(
         target,
         new Selector(selector.kind, selector.memberName, callStructure),
         elements.getTypeMask(node),
         arguments,
-        sourceInformation:
-            sourceInformationBuilder.buildCall(node, node.selector));
+        sourceInformationBuilder.buildCall(node, node.selector));
   }
 
   @override
   ir.Primitive visitIfNotNullDynamicPropertyInvoke(
       ast.Send node,
       ast.Node receiver,
       ast.NodeList argumentsNode,
       Selector selector,
       _) {
     ir.Primitive target = visit(receiver);
     return irBuilder.buildIfNotNullSend(
         target,
         nested(() {
           List<ir.Primitive> arguments = <ir.Primitive>[];
           CallStructure callStructure = translateDynamicArguments(
               argumentsNode, selector.callStructure, arguments);
           return irBuilder.buildDynamicInvocation(
               target,
               new Selector(selector.kind, selector.memberName, callStructure),
               elements.getTypeMask(node),
-              arguments);
+              arguments,
+              sourceInformationBuilder.buildCall(node, node.selector));
         }));
   }
 
   ir.Primitive handleLocalInvoke(
       ast.Send node,
       LocalElement element,
       ast.NodeList argumentsNode,
       CallStructure callStructure,
       _) {
     ir.Primitive function = irBuilder.buildLocalGet(element);
     List<ir.Primitive> arguments = <ir.Primitive>[];
     callStructure =
         translateDynamicArguments(argumentsNode, callStructure, arguments);
     return irBuilder.buildCallInvocation(function, callStructure, arguments,
-        sourceInformation:
-            sourceInformationBuilder.buildCall(node, argumentsNode));
+        sourceInformationBuilder.buildCall(node, argumentsNode));
   }
 
   @override
   ir.Primitive handleStaticFieldGet(ast.Send node, FieldElement field, _) {
     return buildStaticFieldGet(field, sourceInformationBuilder.buildGet(node));
   }
 
   @override
   ir.Primitive handleStaticFieldInvoke(
       ast.Send node,
       FieldElement field,
       ast.NodeList argumentsNode,
       CallStructure callStructure,
       _) {
     SourceInformation src = sourceInformationBuilder.buildGet(node);
     ir.Primitive target = buildStaticFieldGet(field, src);
     List<ir.Primitive> arguments = <ir.Primitive>[];
     callStructure =
         translateDynamicArguments(argumentsNode, callStructure, arguments);
     return irBuilder.buildCallInvocation(
         target,
         callStructure,
         arguments,
-        sourceInformation:
-            sourceInformationBuilder.buildCall(node, argumentsNode));
+        sourceInformationBuilder.buildCall(node, argumentsNode));
   }
 
   @override
   ir.Primitive handleStaticFunctionInvoke(ast.Send node,
       MethodElement function,
       ast.NodeList argumentsNode,
       CallStructure callStructure,
       _) {
     if (compiler.backend.isForeign(function)) {
-      return handleForeignCode(node, function, argumentsNode, callStructure);
+      return handleForeignCode(
+          node,
+          function,
+          argumentsNode,
+          callStructure);
     } else {
       List<ir.Primitive> arguments = <ir.Primitive>[];
       callStructure = translateStaticArguments(argumentsNode, function,
           callStructure, arguments);
       Selector selector = new Selector.call(function.memberName, callStructure);
       return irBuilder.buildInvokeStatic(function, selector, arguments,
           sourceInformationBuilder.buildCall(node, node.selector));
     }
   }
 
   @override
   ir.Primitive handleStaticFunctionIncompatibleInvoke(
       ast.Send node,
       MethodElement function,
       ast.NodeList arguments,
       CallStructure callStructure, _) {
     return irBuilder.buildStaticNoSuchMethod(
         elements.getSelector(node),
-        arguments.nodes.mapToList(visit));
+        arguments.nodes.mapToList(visit),
+        sourceInformationBuilder.buildCall(node, node.selector));
   }
 
   @override
   ir.Primitive handleStaticGetterInvoke(
       ast.Send node,
       FunctionElement getter,
       ast.NodeList argumentsNode,
       CallStructure callStructure,
       _) {
-    ir.Primitive target = buildStaticGetterGet(getter, node);
+    ir.Primitive target = buildStaticGetterGet(
+        getter, node, sourceInformationBuilder.buildGet(node));
     List<ir.Primitive> arguments = <ir.Primitive>[];
     callStructure =
         translateDynamicArguments(argumentsNode, callStructure, arguments);
     return irBuilder.buildCallInvocation(
         target,
         callStructure,
         arguments,
-        sourceInformation:
-            sourceInformationBuilder.buildCall(node, argumentsNode));
+        sourceInformationBuilder.buildCall(node, argumentsNode));
   }
 
   @override
   ir.Primitive visitSuperFieldInvoke(
       ast.Send node,
       FieldElement field,
       ast.NodeList argumentsNode,
       CallStructure callStructure,
       _) {
-    ir.Primitive target = irBuilder.buildSuperFieldGet(field);
+    ir.Primitive target = irBuilder.buildSuperFieldGet(
+        field, sourceInformationBuilder.buildGet(node));
     List<ir.Primitive> arguments = <ir.Primitive>[];
     callStructure =
         translateDynamicArguments(argumentsNode, callStructure, arguments);
     return irBuilder.buildCallInvocation(
         target,
         callStructure,
         arguments,
-        sourceInformation:
-            sourceInformationBuilder.buildCall(node, argumentsNode));
+        sourceInformationBuilder.buildCall(node, argumentsNode));
   }
 
   @override
   ir.Primitive visitSuperGetterInvoke(
       ast.Send node,
       FunctionElement getter,
       ast.NodeList argumentsNode,
       CallStructure callStructure,
       _) {
     ir.Primitive target = irBuilder.buildSuperGetterGet(getter,
         sourceInformationBuilder.buildGet(node));
     List<ir.Primitive> arguments = <ir.Primitive>[];
     callStructure =
         translateDynamicArguments(argumentsNode, callStructure, arguments);
     return irBuilder.buildCallInvocation(
         target,
         callStructure,
         arguments,
-        sourceInformation:
-            sourceInformationBuilder.buildCall(node, argumentsNode));
+        sourceInformationBuilder.buildCall(node, argumentsNode));
   }
 
   @override
   ir.Primitive visitSuperMethodInvoke(
       ast.Send node,
       MethodElement method,
       ast.NodeList argumentsNode,
       CallStructure callStructure,
       _) {
     List<ir.Primitive> arguments = <ir.Primitive>[];
     callStructure = translateStaticArguments(argumentsNode, method,
         callStructure, arguments);
     return irBuilder.buildSuperMethodInvocation(
         method,
         callStructure,
         arguments,
-        sourceInformation:
-            sourceInformationBuilder.buildCall(node, node.selector));
+        sourceInformationBuilder.buildCall(node, node.selector));
   }
 
   @override
   ir.Primitive visitSuperMethodIncompatibleInvoke(
       ast.Send node,
       MethodElement method,
       ast.NodeList arguments,
       CallStructure callStructure, _) {
     List<ir.Primitive> normalizedArguments = <ir.Primitive>[];
     CallStructure normalizedCallStructure =
       translateDynamicArguments(arguments, callStructure, normalizedArguments);
     return buildSuperNoSuchMethod(
         new Selector.call(method.memberName, normalizedCallStructure),
         elements.getTypeMask(node),
-        normalizedArguments);
+        normalizedArguments,
+        sourceInformationBuilder.buildCall(node, arguments));
   }
 
   @override
   ir.Primitive visitUnresolvedSuperInvoke(
       ast.Send node,
       Element element,
       ast.NodeList argumentsNode,
       Selector selector, _) {
     List<ir.Primitive> arguments = <ir.Primitive>[];
     CallStructure callStructure = translateDynamicArguments(
         argumentsNode, selector.callStructure, arguments);
     // TODO(johnniwinther): Supply a member name to the visit function instead
     // of looking it up in elements.
     return buildSuperNoSuchMethod(
         new Selector.call(elements.getSelector(node).memberName, callStructure),
         elements.getTypeMask(node),
-        arguments);
+        arguments,
+        sourceInformationBuilder.buildCall(node, argumentsNode));
   }
 
   @override
   ir.Primitive visitThisInvoke(
       ast.Send node,
       ast.NodeList arguments,
       CallStructure callStructure,
       _) {
     return translateCallInvoke(
         irBuilder.buildThis(),
@@ skipping 18 matching lines @@
   }
 
   @override
   ir.Primitive visitIndexSet(
        ast.SendSet node,
        ast.Node receiver,
        ast.Node index,
        ast.Node rhs,
        _) {
     return irBuilder.buildDynamicIndexSet(
-        visit(receiver), elements.getTypeMask(node), visit(index), visit(rhs));
+        visit(receiver),
+        elements.getTypeMask(node),
+        visit(index),
+        visit(rhs),
+        sourceInformationBuilder.buildIndexSet(node));
   }
 
   @override
   ir.Primitive visitSuperIndexSet(
       ast.SendSet node,
       FunctionElement function,
       ast.Node index,
       ast.Node rhs,
       _) {
-    return irBuilder.buildSuperIndexSet(function, visit(index), visit(rhs));
+    return irBuilder.buildSuperIndexSet(
+        function,
+        visit(index),
+        visit(rhs),
+        sourceInformationBuilder.buildIndexSet(node));
   }
 
   ir.Primitive translateCompounds(
       ast.SendSet node,
       ir.Primitive getValue(),
       CompoundRhs rhs,
       void setValue(ir.Primitive value)) {
     ir.Primitive value = getValue();
     op.BinaryOperator operator = rhs.operator;
     if (operator.kind == op.BinaryOperatorKind.IF_NULL) {
@@ skipping 20 matching lines @@
     TypeMask operatorTypeMask =
         elements.getOperatorTypeMaskInComplexSendSet(node);
     SourceInformation operatorSourceInformation =
         sourceInformationBuilder.buildCall(node, node.assignmentOperator);
     ir.Primitive result = irBuilder.buildDynamicInvocation(
         value,
         new Selector(operatorSelector.kind, operatorSelector.memberName,
             callStructure),
         operatorTypeMask,
         arguments,
-        sourceInformation: operatorSourceInformation);
+        operatorSourceInformation);
     setValue(result);
     return rhs.kind == CompoundKind.POSTFIX ? value : result;
   }
 
   ir.Primitive translateSetIfNull(
       ast.SendSet node,
       ir.Primitive getValue(),
       ast.Node rhs,
       void setValue(ir.Primitive value)) {
     ir.Primitive value = getValue();
@@ skipping 10 matching lines @@
   ir.Primitive handleDynamicSet(
       ast.SendSet node,
       ast.Node receiver,
       Name name,
       ast.Node rhs,
       _) {
     return irBuilder.buildDynamicSet(
         translateReceiver(receiver),
         new Selector.setter(name),
         elements.getTypeMask(node),
-        visit(rhs));
+        visit(rhs),
+        sourceInformationBuilder.buildAssignment(node));
   }
 
   @override
   ir.Primitive visitIfNotNullDynamicPropertySet(
       ast.SendSet node,
       ast.Node receiver,
       Name name,
       ast.Node rhs,
       _) {
     ir.Primitive target = visit(receiver);
     return irBuilder.buildIfNotNullSend(
         target,
         nested(() => irBuilder.buildDynamicSet(
             target,
             new Selector.setter(name),
             elements.getTypeMask(node),
-            visit(rhs))));
+            visit(rhs),
+            sourceInformationBuilder.buildAssignment(node))));
   }
 
   @override
   ir.Primitive handleLocalSet(
       ast.SendSet node,
       LocalElement element,
       ast.Node rhs,
       _) {
     ir.Primitive value = visit(rhs);
     value = checkTypeVsElement(value, element);
-    return irBuilder.buildLocalVariableSet(element, value);
+    return irBuilder.buildLocalVariableSet(element, value,
+        sourceInformationBuilder.buildAssignment(node));
   }
 
   @override
   ir.Primitive handleStaticFieldSet(
       ast.SendSet node,
       FieldElement field,
       ast.Node rhs,
       _) {
     ir.Primitive value = visit(rhs);
-    irBuilder.addPrimitive(new ir.SetStatic(field, value));
+    irBuilder.addPrimitive(new ir.SetStatic(field, value,
+        sourceInformationBuilder.buildAssignment(node)));
     return value;
   }
 
   @override
   ir.Primitive visitSuperFieldSet(
       ast.SendSet node,
       FieldElement field,
       ast.Node rhs,
       _) {
-    return irBuilder.buildSuperFieldSet(field, visit(rhs));
+    return irBuilder.buildSuperFieldSet(field, visit(rhs),
+        sourceInformationBuilder.buildAssignment(node));
   }
 
   @override
   ir.Primitive visitSuperSetterSet(
       ast.SendSet node,
       FunctionElement setter,
       ast.Node rhs,
       _) {
-    return irBuilder.buildSuperSetterSet(setter, visit(rhs));
+    return irBuilder.buildSuperSetterSet(setter, visit(rhs),
+        sourceInformationBuilder.buildAssignment(node));
   }
 
   @override
   ir.Primitive visitUnresolvedSuperIndexSet(
       ast.Send node,
       Element element,
       ast.Node index,
       ast.Node rhs,
       arg) {
     return giveup(node, 'visitUnresolvedSuperIndexSet');
   }
 
   @override
   ir.Primitive handleStaticSetterSet(
       ast.SendSet node,
       FunctionElement setter,
       ast.Node rhs,
       _) {
-    return irBuilder.buildStaticSetterSet(setter, visit(rhs));
+    return irBuilder.buildStaticSetterSet(setter, visit(rhs),
+        sourceInformationBuilder.buildAssignment(node));
   }
 
   @override
   ir.Primitive handleTypeLiteralConstantCompounds(
       ast.SendSet node,
       ConstantExpression constant,
       CompoundRhs rhs,
       arg) {
     SourceInformation src = sourceInformationBuilder.buildGet(node);
     return translateCompounds(node, () {
@@ skipping 27 matching lines @@
         return irBuilder.buildDynamicGet(
             target,
             new Selector.getter(name),
             elements.getGetterTypeMaskInComplexSendSet(node),
             sourceInformationBuilder.buildGet(node));
       }, rhs, (ir.Primitive result) {
         irBuilder.buildDynamicSet(
             target,
             new Selector.setter(name),
             elements.getTypeMask(node),
-            result);
+            result,
+            sourceInformationBuilder.buildAssignment(node));
       });
     }
     return node.isConditional
         ? irBuilder.buildIfNotNullSend(target, nested(helper))
         : helper();
   }
 
   @override
   ir.Primitive handleDynamicSetIfNulls(
       ast.Send node,
       ast.Node receiver,
       Name name,
       ast.Node rhs,
       _) {
     ir.Primitive target = translateReceiver(receiver);
     ir.Primitive helper() {
       return translateSetIfNull(node, () {
         return irBuilder.buildDynamicGet(
             target,
             new Selector.getter(name),
             elements.getGetterTypeMaskInComplexSendSet(node),
             sourceInformationBuilder.buildGet(node));
       }, rhs, (ir.Primitive result) {
         irBuilder.buildDynamicSet(
             target,
             new Selector.setter(name),
             elements.getTypeMask(node),
-            result);
+            result,
+            sourceInformationBuilder.buildAssignment(node));
       });
     }
     return node.isConditional
         ? irBuilder.buildIfNotNullSend(target, nested(helper))
         : helper();
   }
 
-  ir.Primitive buildLocalNoSuchSetter(LocalElement local, ir.Primitive value) {
+  ir.Primitive buildLocalNoSuchSetter(
+      LocalElement local,
+      ir.Primitive value,
+      SourceInformation sourceInformation) {
     Selector selector = new Selector.setter(
         new Name(local.name, local.library, isSetter: true));
-    return irBuilder.buildStaticNoSuchMethod(selector, [value]);
+    return irBuilder.buildStaticNoSuchMethod(
+        selector, [value], sourceInformation);
   }
 
   @override
   ir.Primitive handleLocalCompounds(
       ast.SendSet node,
       LocalElement local,
       CompoundRhs rhs,
       arg,
       {bool isSetterValid}) {
     return translateCompounds(node, () {
       return irBuilder.buildLocalGet(local);
     }, rhs, (ir.Primitive result) {
       if (isSetterValid) {
-        irBuilder.buildLocalVariableSet(local, result);
+        irBuilder.buildLocalVariableSet(
+            local, result,
+            sourceInformationBuilder.buildAssignment(node));
       } else {
         Selector selector = new Selector.setter(
             new Name(local.name, local.library, isSetter: true));
-        irBuilder.buildStaticNoSuchMethod(selector, <ir.Primitive>[result]);
+        irBuilder.buildStaticNoSuchMethod(
+            selector, <ir.Primitive>[result],
+            sourceInformationBuilder.buildAssignment(node));
       }
     });
   }
 
   @override
   ir.Primitive handleLocalSetIfNulls(
       ast.SendSet node,
       LocalElement local,
       ast.Node rhs,
       _,
       {bool isSetterValid}) {
     return translateSetIfNull(node, () {
-      return irBuilder.buildLocalGet(local);
+      return irBuilder.buildLocalGet(
+          local, sourceInformation: sourceInformationBuilder.buildGet(node));
     }, rhs, (ir.Primitive result) {
+      SourceInformation sourceInformation =
+          sourceInformationBuilder.buildAssignment(node);
       if (isSetterValid) {
-        irBuilder.buildLocalVariableSet(local, result);
+        irBuilder.buildLocalVariableSet(
+            local, result, sourceInformation);
       } else {
         Selector selector = new Selector.setter(
             new Name(local.name, local.library, isSetter: true));
-        irBuilder.buildStaticNoSuchMethod(selector, <ir.Primitive>[result]);
+        irBuilder.buildStaticNoSuchMethod(
+            selector, <ir.Primitive>[result], sourceInformation);
       }
     });
   }
 
   @override
   ir.Primitive handleStaticCompounds(
       ast.SendSet node,
       Element getter,
       CompoundGetter getterKind,
       Element setter,
       CompoundSetter setterKind,
       CompoundRhs rhs,
       arg) {
     return translateCompounds(node, () {
+      SourceInformation sourceInformation =
+          sourceInformationBuilder.buildGet(node);
       switch (getterKind) {
         case CompoundGetter.FIELD:
-          SourceInformation src = sourceInformationBuilder.buildGet(node);
-          return buildStaticFieldGet(getter, src);
+          return buildStaticFieldGet(getter, sourceInformation);
         case CompoundGetter.GETTER:
-          return buildStaticGetterGet(getter, node);
+          return buildStaticGetterGet(getter, node, sourceInformation);
         case CompoundGetter.METHOD:
           return irBuilder.addPrimitive(new ir.GetStatic(getter,
-              isFinal: true));
+              sourceInformation: sourceInformation, isFinal: true));
         case CompoundGetter.UNRESOLVED:
           return irBuilder.buildStaticNoSuchMethod(
               new Selector.getter(new Name(getter.name, getter.library)),
-              <ir.Primitive>[]);
+              <ir.Primitive>[],
+              sourceInformation);
       }
     }, rhs, (ir.Primitive result) {
+      SourceInformation sourceInformation =
+          sourceInformationBuilder.buildAssignment(node);
       switch (setterKind) {
         case CompoundSetter.FIELD:
-          irBuilder.addPrimitive(new ir.SetStatic(setter, result));
+          irBuilder.addPrimitive(
+              new ir.SetStatic(setter, result, sourceInformation));
           return;
         case CompoundSetter.SETTER:
-          irBuilder.buildStaticSetterSet(setter, result);
+          irBuilder.buildStaticSetterSet(setter, result, sourceInformation);
           return;
         case CompoundSetter.INVALID:
           irBuilder.buildStaticNoSuchMethod(
               new Selector.setter(new Name(setter.name, setter.library)),
-              <ir.Primitive>[result]);
+              <ir.Primitive>[result],
+              sourceInformation);
           return;
       }
     });
   }
 
   @override
   ir.Primitive handleStaticSetIfNulls(
       ast.SendSet node,
       Element getter,
       CompoundGetter getterKind,
       Element setter,
       CompoundSetter setterKind,
       ast.Node rhs,
       _) {
     return translateSetIfNull(node, () {
+      SourceInformation sourceInformation =
+          sourceInformationBuilder.buildGet(node);
       switch (getterKind) {
         case CompoundGetter.FIELD:
-          SourceInformation src = sourceInformationBuilder.buildGet(node);
-          return buildStaticFieldGet(getter, src);
+          return buildStaticFieldGet(getter, sourceInformation);
         case CompoundGetter.GETTER:
-          return buildStaticGetterGet(getter, node);
+          return buildStaticGetterGet(getter, node, sourceInformation);
         case CompoundGetter.METHOD:
           return irBuilder.addPrimitive(new ir.GetStatic(getter,
+              sourceInformation: sourceInformation,
               isFinal: true));
         case CompoundGetter.UNRESOLVED:
           return irBuilder.buildStaticNoSuchMethod(
               new Selector.getter(new Name(getter.name, getter.library)),
-              <ir.Primitive>[]);
+              <ir.Primitive>[],
+              sourceInformation);
       }
     }, rhs, (ir.Primitive result) {
+      SourceInformation sourceInformation =
+          sourceInformationBuilder.buildAssignment(node);
       switch (setterKind) {
         case CompoundSetter.FIELD:
-          irBuilder.addPrimitive(new ir.SetStatic(setter, result));
+          irBuilder.addPrimitive(new ir.SetStatic(
+              setter, result, sourceInformation));
           return;
         case CompoundSetter.SETTER:
-          irBuilder.buildStaticSetterSet(setter, result);
+          irBuilder.buildStaticSetterSet(setter, result, sourceInformation);
           return;
         case CompoundSetter.INVALID:
           irBuilder.buildStaticNoSuchMethod(
               new Selector.setter(new Name(setter.name, setter.library)),
-              <ir.Primitive>[result]);
+              <ir.Primitive>[result],
+              sourceInformation);
           return;
       }
     });
   }
 
-  ir.Primitive buildSuperNoSuchGetter(Element element, TypeMask mask) {
+  ir.Primitive buildSuperNoSuchGetter(
+      Element element,
+      TypeMask mask,
+      SourceInformation sourceInformation) {
     return buildSuperNoSuchMethod(
         new Selector.getter(new Name(element.name, element.library)),
         mask,
-        const <ir.Primitive>[]);
+        const <ir.Primitive>[],
+        sourceInformation);
   }
 
-  ir.Primitive buildSuperNoSuchSetter(Element element,
-                                      TypeMask mask,
-                                      ir.Primitive value) {
+  ir.Primitive buildSuperNoSuchSetter(
+      Element element,
+      TypeMask mask,
+      ir.Primitive value,
+      SourceInformation sourceInformation) {
     return buildSuperNoSuchMethod(
         new Selector.setter(new Name(element.name, element.library)),
         mask,
-        <ir.Primitive>[value]);
+        <ir.Primitive>[value],
+        sourceInformation);
   }
 
   @override
   ir.Primitive handleSuperCompounds(
       ast.SendSet node,
       Element getter,
       CompoundGetter getterKind,
       Element setter,
       CompoundSetter setterKind,
       CompoundRhs rhs,
       arg) {
     return translateCompounds(node, () {
       switch (getterKind) {
         case CompoundGetter.FIELD:
-          return irBuilder.buildSuperFieldGet(getter);
+          return irBuilder.buildSuperFieldGet(
+              getter, sourceInformationBuilder.buildGet(node));
         case CompoundGetter.GETTER:
           return irBuilder.buildSuperGetterGet(
               getter, sourceInformationBuilder.buildGet(node));
         case CompoundGetter.METHOD:
-          return irBuilder.buildSuperMethodGet(getter);
+          return irBuilder.buildSuperMethodGet(
+              getter, sourceInformationBuilder.buildGet(node));
         case CompoundGetter.UNRESOLVED:
           return buildSuperNoSuchGetter(
-              getter, elements.getGetterTypeMaskInComplexSendSet(node));
+              getter, elements.getGetterTypeMaskInComplexSendSet(node),
+              sourceInformationBuilder.buildGet(node));
       }
     }, rhs, (ir.Primitive result) {
       switch (setterKind) {
         case CompoundSetter.FIELD:
-          irBuilder.buildSuperFieldSet(setter, result);
+          irBuilder.buildSuperFieldSet(setter, result,
+              sourceInformationBuilder.buildAssignment(node));
           return;
         case CompoundSetter.SETTER:
-          irBuilder.buildSuperSetterSet(setter, result);
+          irBuilder.buildSuperSetterSet(setter, result,
+              sourceInformationBuilder.buildAssignment(node));
           return;
         case CompoundSetter.INVALID:
           buildSuperNoSuchSetter(
-              setter, elements.getTypeMask(node), result);
+              setter, elements.getTypeMask(node), result,
+              sourceInformationBuilder.buildAssignment(node));
           return;
       }
     });
   }
 
   @override
   ir.Primitive handleSuperSetIfNulls(
       ast.SendSet node,
       Element getter,
       CompoundGetter getterKind,
       Element setter,
       CompoundSetter setterKind,
       ast.Node rhs,
       _) {
     return translateSetIfNull(node, () {
       switch (getterKind) {
         case CompoundGetter.FIELD:
-          return irBuilder.buildSuperFieldGet(getter);
+          return irBuilder.buildSuperFieldGet(
+              getter, sourceInformationBuilder.buildGet(node));
         case CompoundGetter.GETTER:
           return irBuilder.buildSuperGetterGet(
               getter, sourceInformationBuilder.buildGet(node));
         case CompoundGetter.METHOD:
-          return irBuilder.buildSuperMethodGet(getter);
+          return irBuilder.buildSuperMethodGet(
+              getter, sourceInformationBuilder.buildGet(node));
         case CompoundGetter.UNRESOLVED:
           return buildSuperNoSuchGetter(
               getter,
-              elements.getGetterTypeMaskInComplexSendSet(node));
+              elements.getGetterTypeMaskInComplexSendSet(node),
+              sourceInformationBuilder.buildGet(node));
       }
     }, rhs, (ir.Primitive result) {
       switch (setterKind) {
         case CompoundSetter.FIELD:
-          irBuilder.buildSuperFieldSet(setter, result);
+          irBuilder.buildSuperFieldSet(
+              setter, result,
+              sourceInformationBuilder.buildAssignment(node));
           return;
         case CompoundSetter.SETTER:
-          irBuilder.buildSuperSetterSet(setter, result);
+          irBuilder.buildSuperSetterSet(
+              setter, result,
+              sourceInformationBuilder.buildAssignment(node));
           return;
         case CompoundSetter.INVALID:
           buildSuperNoSuchSetter(
-              setter, elements.getTypeMask(node), result);
+              setter, elements.getTypeMask(node), result,
+              sourceInformationBuilder.buildAssignment(node));
           return;
       }
     });
   }
 
   @override
   ir.Primitive handleTypeVariableTypeLiteralCompounds(
       ast.SendSet node,
       TypeVariableElement typeVariable,
       CompoundRhs rhs,
@@ skipping 30 matching lines @@
     return translateCompounds(node, () {
       Selector selector = new Selector.index();
       List<ir.Primitive> arguments = <ir.Primitive>[indexValue];
       CallStructure callStructure =
           normalizeDynamicArguments(selector.callStructure, arguments);
       return irBuilder.buildDynamicInvocation(
           target,
           new Selector(selector.kind, selector.memberName, callStructure),
           elements.getGetterTypeMaskInComplexSendSet(node),
           arguments,
-          sourceInformation:
           sourceInformationBuilder.buildCall(receiver, node));
     }, rhs, (ir.Primitive result) {
       irBuilder.buildDynamicIndexSet(
           target,
           elements.getTypeMask(node),
           indexValue,
-          result);
+          result,
+          sourceInformationBuilder.buildIndexSet(node));
     });
   }
 
   @override
   ir.Primitive handleSuperIndexCompounds(
       ast.SendSet node,
       Element indexFunction,
       Element indexSetFunction,
       ast.Node index,
       CompoundRhs rhs,
       arg,
       {bool isGetterValid,
        bool isSetterValid}) {
     ir.Primitive indexValue = visit(index);
     return translateCompounds(node, () {
-      return isGetterValid
-          ? irBuilder.buildSuperIndex(indexFunction, indexValue)
-          : buildSuperNoSuchMethod(
-              new Selector.index(),
-              elements.getGetterTypeMaskInComplexSendSet(node),
-              <ir.Primitive>[indexValue]);
+      if (isGetterValid) {
+        return irBuilder.buildSuperIndex(
+            indexFunction,
+            indexValue,
+            sourceInformationBuilder.buildIndex(node));
+      } else {
+        return buildSuperNoSuchMethod(
+            new Selector.index(),
+            elements.getGetterTypeMaskInComplexSendSet(node),
+            <ir.Primitive>[indexValue],
+            sourceInformationBuilder.buildIndex(node));
+      }
     }, rhs, (ir.Primitive result) {
       if (isSetterValid) {
-        irBuilder.buildSuperIndexSet(indexSetFunction, indexValue, result);
+        irBuilder.buildSuperIndexSet(indexSetFunction, indexValue, result,
+            sourceInformationBuilder.buildIndexSet(node));
       } else {
         buildSuperNoSuchMethod(
             new Selector.indexSet(),
             elements.getTypeMask(node),
-            <ir.Primitive>[indexValue, result]);
+            <ir.Primitive>[indexValue, result],
+            sourceInformationBuilder.buildIndexSet(node));
       }
     });
   }
 
   /// Build code to handle foreign code, that is, native JavaScript code, or
   /// builtin values and operations of the backend.
   ir.Primitive handleForeignCode(ast.Send node,
       MethodElement function,
       ast.NodeList argumentList,
       CallStructure callStructure) {
@@ skipping 75 matching lines @@
                   ' and number of arguments.'});
           return irBuilder.buildNullConstant();
         }
 
         if (HasCapturedPlaceholders.check(behavior.codeTemplate.ast)) {
           reporter.reportErrorMessage(node, MessageKind.JS_PLACEHOLDER_CAPTURE);
           return irBuilder.buildNullConstant();
         }
 
         return irBuilder.buildForeignCode(behavior.codeTemplate, arguments,
-            behavior);
+            behavior, sourceInformationBuilder.buildForeignCode(node));
 
       case 'DART_CLOSURE_TO_JS':
       // TODO(ahe): This should probably take care to wrap the closure in
       // another closure that saves the current isolate.
       case 'RAW_DART_FUNCTION_REF':
         validateArgumentCount(exactly: 1);
 
         ast.Node argument = node.arguments.single;
         FunctionElement closure = elements[argument].implementation;
         if (!Elements.isStaticOrTopLevelFunction(closure)) {
           internalError(argument,
               'only static or toplevel function supported');
         }
         if (closure.functionSignature.hasOptionalParameters) {
           internalError(argument,
               'closures with optional parameters not supported');
         }
         return irBuilder.buildForeignCode(
             js.js.expressionTemplateYielding(
                 backend.emitter.staticFunctionAccess(closure)),
             <ir.Primitive>[],
             NativeBehavior.PURE,
+            sourceInformationBuilder.buildForeignCode(node),
             dependency: closure);
 
       case 'JS_BUILTIN':
       // The first argument is a description of the type and effect of the
       // builtin, which has already been analyzed in the frontend.  The second
       // argument must be a [JsBuiltin] value.  All other arguments are
       // values used by the JavaScript template that is associated with the
       // builtin.
         validateArgumentCount(minimum: 2);
 
         ast.Node builtin = argumentNodes.tail.head;
         JsBuiltin value = getEnumValue(builtin, helpers.jsBuiltinEnum,
             JsBuiltin.values);
         js.Template template = backend.emitter.builtinTemplateFor(value);
         List<ir.Primitive> arguments =
         argumentNodes.skip(2).mapToList(visit, growable: false);
-        return irBuilder.buildForeignCode(template, arguments, behavior);
+        return irBuilder.buildForeignCode(template, arguments, behavior,
+            sourceInformationBuilder.buildForeignCode(node));
 
       case 'JS_EMBEDDED_GLOBAL':
         validateArgumentCount(exactly: 2);
 
         String name = expectStringConstant(argumentNodes.tail.head);
         js.Expression access =
         backend.emitter.generateEmbeddedGlobalAccess(name);
         js.Template template = js.js.expressionTemplateYielding(access);
-        return irBuilder.buildForeignCode(template, <ir.Primitive>[], behavior);
+        return irBuilder.buildForeignCode(template, <ir.Primitive>[], behavior,
+            sourceInformationBuilder.buildForeignCode(node));
 
       case 'JS_INTERCEPTOR_CONSTANT':
         validateArgumentCount(exactly: 1);
 
         ast.Node argument = argumentNodes.head;
         ir.Primitive argumentValue = visit(argument);
         if (argumentValue is ir.Constant && argumentValue.value.isType) {
           TypeConstantValue constant = argumentValue.value;
           ConstantValue interceptorValue =
           new InterceptorConstantValue(constant.representedType);
@@ skipping 30 matching lines @@
             value = compiler.useContentSecurityPolicy;
             break;
           default:
             internalError(node, 'Unknown internal flag "$name".');
         }
         return irBuilder.buildBooleanConstant(value);
 
       case 'JS_STRING_CONCAT':
         validateArgumentCount(exactly: 2);
         List<ir.Primitive> arguments = argumentNodes.mapToList(visit);
-        return irBuilder.buildStringConcatenation(arguments);
+        return irBuilder.buildStringConcatenation(arguments,
+            sourceInformationBuilder.buildForeignCode(node));
 
       case 'JS_CURRENT_ISOLATE_CONTEXT':
         validateArgumentCount(exactly: 0);
 
         if (!compiler.hasIsolateSupport) {
           // If the isolate library is not used, we just generate code
           // to fetch the current isolate.
           continue getStaticState;
         }
         return buildIsolateHelperInvocation(helpers.currentIsolate,
             CallStructure.NO_ARGS);
 
       getStaticState: case 'JS_GET_STATIC_STATE':
         validateArgumentCount(exactly: 0);
 
         return irBuilder.buildForeignCode(
             js.js.parseForeignJS(backend.namer.staticStateHolder),
             const <ir.Primitive>[],
-            NativeBehavior.DEPENDS_OTHER);
+            NativeBehavior.DEPENDS_OTHER,
+            sourceInformationBuilder.buildForeignCode(node));
 
       case 'JS_SET_STATIC_STATE':
         validateArgumentCount(exactly: 1);
 
         ir.Primitive value = visit(argumentNodes.single);
         String isolateName = backend.namer.staticStateHolder;
         return irBuilder.buildForeignCode(
             js.js.parseForeignJS("$isolateName = #"),
             <ir.Primitive>[value],
-            NativeBehavior.CHANGES_OTHER);
+            NativeBehavior.CHANGES_OTHER,
+            sourceInformationBuilder.buildForeignCode(node));
 
       case 'JS_CALL_IN_ISOLATE':
         validateArgumentCount(exactly: 2);
 
         if (!compiler.hasIsolateSupport) {
           ir.Primitive closure = visit(argumentNodes.tail.head);
           return irBuilder.buildCallInvocation(closure, CallStructure.NO_ARGS,
-              const <ir.Primitive>[]);
+              const <ir.Primitive>[],
+              sourceInformationBuilder.buildForeignCode(node));
         }
         return buildIsolateHelperInvocation(helpers.callInIsolate,
             CallStructure.TWO_ARGS);
 
       default:
         return giveup(node, 'unplemented native construct: ${function.name}');
     }
   }
 
   /// Evaluates a string interpolation and appends each part to [accumulator]
@@ skipping 13 matching lines @@
       // do not bother to include them.
       if (!node.dartString.isEmpty) {
         accumulator.add(irBuilder.buildDartStringConstant(node.dartString));
       }
     } else if (node is ast.ParenthesizedExpression) {
       buildStringParts(node.expression, accumulator);
     } else {
       ir.Primitive value = visit(node);
       accumulator.add(irBuilder.buildStaticFunctionInvocation(
           helpers.stringInterpolationHelper,
-          <ir.Primitive>[value]));
+          <ir.Primitive>[value],
+          sourceInformationBuilder.buildStringInterpolation(node)));
     }
   }
 
   ir.Primitive visitStringJuxtaposition(ast.StringJuxtaposition node) {
     assert(irBuilder.isOpen);
     List<ir.Primitive> parts = <ir.Primitive>[];
     buildStringParts(node, parts);
-    return irBuilder.buildStringConcatenation(parts);
+    return irBuilder.buildStringConcatenation(parts,
+        sourceInformationBuilder.buildStringInterpolation(node));
   }
 
   ir.Primitive visitStringInterpolation(ast.StringInterpolation node) {
     assert(irBuilder.isOpen);
     List<ir.Primitive> parts = <ir.Primitive>[];
     buildStringParts(node, parts);
-    return irBuilder.buildStringConcatenation(parts);
+    return irBuilder.buildStringConcatenation(parts,
+        sourceInformationBuilder.buildStringInterpolation(node));
   }
 
   ir.Primitive translateConstant(ast.Node node) {
     assert(irBuilder.isOpen);
     return irBuilder.buildConstant(
         getConstantForNode(node),
         sourceInformation: sourceInformationBuilder.buildGet(node));
   }
 
   ir.Primitive visitThrow(ast.Throw node) {
     assert(irBuilder.isOpen);
     // This function is not called for throw expressions occurring as
     // statements.
     return irBuilder.buildNonTailThrow(visit(node.expression));
   }
 
-  ir.Primitive buildSuperNoSuchMethod(Selector selector,
+  ir.Primitive buildSuperNoSuchMethod(
+      Selector selector,
       TypeMask mask,
-      List<ir.Primitive> arguments) {
+      List<ir.Primitive> arguments,
+      SourceInformation sourceInformation) {
     ClassElement cls = elements.analyzedElement.enclosingClass;
     MethodElement element = cls.lookupSuperMember(Identifiers.noSuchMethod_);
     if (!Selectors.noSuchMethod_.signatureApplies(element)) {
       element = compiler.coreClasses.objectClass.lookupMember(
           Identifiers.noSuchMethod_);
     }
     return irBuilder.buildSuperMethodInvocation(
         element,
         Selectors.noSuchMethod_.callStructure,
-        [irBuilder.buildInvocationMirror(selector, arguments)]);
+        [irBuilder.buildInvocationMirror(selector, arguments)],
+        sourceInformation);
   }
 
   @override
   ir.Primitive visitUnresolvedCompound(
       ast.Send node,
       Element element,
       op.AssignmentOperator operator,
       ast.Node rhs, _) {
-    // TODO(asgerf): What is unresolved? The getter and/or the setter?
-    //               If it was the setter, we must evaluate the right-hand side.
-    return irBuilder.buildStaticNoSuchMethod(elements.getSelector(node), []);
+    return irBuilder.buildStaticNoSuchMethod(
+        new Selector.getter(new Name(element.name, element.library)),
+        [],
+        sourceInformationBuilder.buildGet(node));
   }
 
   @override
   ir.Primitive visitUnresolvedClassConstructorInvoke(
       ast.NewExpression node,
       Element element,
       DartType type,
       ast.NodeList arguments,
       Selector selector, _) {
     // If the class is missing it's a runtime error.
     ir.Primitive message =
         irBuilder.buildStringConstant("Unresolved class: '${element.name}'");
     return irBuilder.buildStaticFunctionInvocation(
         helpers.throwRuntimeError,
-        <ir.Primitive>[message]);
+        <ir.Primitive>[message],
+        sourceInformationBuilder.buildNew(node));
   }
 
   @override
   ir.Primitive visitUnresolvedConstructorInvoke(
       ast.NewExpression node,
       Element constructor,
       DartType type,
       ast.NodeList argumentsNode,
       Selector selector, _) {
     // If the class is there but the constructor is missing, it's an NSM error.
     List<ir.Primitive> arguments = <ir.Primitive>[];
     CallStructure callStructure = translateDynamicArguments(
         argumentsNode, selector.callStructure, arguments);
     return irBuilder.buildStaticNoSuchMethod(
         new Selector(selector.kind, selector.memberName, callStructure),
-        arguments);
+        arguments,
+        sourceInformationBuilder.buildNew(node));
   }
 
   @override
   ir.Primitive visitConstructorIncompatibleInvoke(
       ast.NewExpression node,
       ConstructorElement constructor,
       DartType type,
       ast.NodeList argumentsNode,
       CallStructure callStructure, _) {
     List<ir.Primitive> arguments = <ir.Primitive>[];
     callStructure =
         translateDynamicArguments(argumentsNode, callStructure, arguments);
     return irBuilder.buildStaticNoSuchMethod(
-        new Selector.call(constructor.memberName, callStructure), arguments);
+        new Selector.call(constructor.memberName, callStructure), arguments,
+        sourceInformationBuilder.buildNew(node));
   }
 
   @override
   ir.Primitive visitUnresolvedGet(
       ast.Send node,
       Element element, _) {
-    return irBuilder.buildStaticNoSuchMethod(elements.getSelector(node), []);
+    return irBuilder.buildStaticNoSuchMethod(
+        elements.getSelector(node), [],
+        sourceInformationBuilder.buildGet(node));
   }
 
   @override
   ir.Primitive visitUnresolvedInvoke(
       ast.Send node,
       Element element,
       ast.NodeList arguments,
       Selector selector, _) {
-    return irBuilder.buildStaticNoSuchMethod(elements.getSelector(node),
-        arguments.nodes.mapToList(visit));
+    return irBuilder.buildStaticNoSuchMethod(
+        elements.getSelector(node),
+        arguments.nodes.mapToList(visit),
+        sourceInformationBuilder.buildCall(node, node.selector));
   }
 
   @override
   ir.Primitive visitUnresolvedRedirectingFactoryConstructorInvoke(
        ast.NewExpression node,
        ConstructorElement constructor,
        InterfaceType type,
        ast.NodeList argumentsNode,
        CallStructure callStructure, _) {
     String nameString = Elements.reconstructConstructorName(constructor);
     Name name = new Name(nameString, constructor.library);
     List<ir.Primitive> arguments = <ir.Primitive>[];
     callStructure =
         translateDynamicArguments(argumentsNode, callStructure, arguments);
     return irBuilder.buildStaticNoSuchMethod(
         new Selector.call(name, callStructure),
-        arguments);
+        arguments,
+        sourceInformationBuilder.buildNew(node));
   }
 
   @override
   ir.Primitive visitUnresolvedSet(
       ast.Send node,
       Element element,
       ast.Node rhs, _) {
     return irBuilder.buildStaticNoSuchMethod(elements.getSelector(node),
-        [visit(rhs)]);
+        [visit(rhs)],
+        sourceInformationBuilder.buildAssignment(node));
   }
 
   @override
   ir.Primitive visitUnresolvedSuperIndex(
       ast.Send node,
       Element function,
       ast.Node index, _) {
     // Assume the index getter is missing.
     return buildSuperNoSuchMethod(
-        new Selector.index(), elements.getTypeMask(node), [visit(index)]);
+        new Selector.index(), elements.getTypeMask(node), [visit(index)],
+        sourceInformationBuilder.buildIndex(node));
   }
 
   @override
   ir.Primitive visitUnresolvedSuperBinary(
       ast.Send node,
       Element element,
       op.BinaryOperator operator,
       ast.Node argument, _) {
     return buildSuperNoSuchMethod(
         elements.getSelector(node),
         elements.getTypeMask(node),
-        [visit(argument)]);
+        [visit(argument)],
+        sourceInformationBuilder.buildCall(node, node.selector));
   }
 
   @override
   ir.Primitive visitUnresolvedSuperUnary(
       ast.Send node,
       op.UnaryOperator operator,
       Element element, _) {
     return buildSuperNoSuchMethod(
-        elements.getSelector(node), elements.getTypeMask(node), []);
+        elements.getSelector(node), elements.getTypeMask(node), [],
+        sourceInformationBuilder.buildCall(node, node.selector));
   }
 
   @override
   ir.Primitive bulkHandleNode(ast.Node node, String message, _) {
     return giveup(node, "Unhandled node: ${message.replaceAll('#', '$node')}");
   }
 
   @override
   ir.Primitive bulkHandleError(ast.Node node, ErroneousElement error, _) {
     return irBuilder.buildNullConstant();
   }
 
   @override
   ir.Primitive visitClassTypeLiteralSet(
       ast.SendSet node,
       TypeConstantExpression constant,
       ast.Node rhs, _) {
     InterfaceType type = constant.type;
     ClassElement element = type.element;
     return irBuilder.buildStaticNoSuchMethod(
         new Selector.setter(element.memberName),
-        [visit(rhs)]);
+        [visit(rhs)],
+        sourceInformationBuilder.buildAssignment(node));
   }
 
   @override
   ir.Primitive visitTypedefTypeLiteralSet(
       ast.SendSet node,
       TypeConstantExpression constant,
       ast.Node rhs, _) {
     TypedefType type = constant.type;
     TypedefElement element = type.element;
     return irBuilder.buildStaticNoSuchMethod(
         new Selector.setter(element.memberName),
-        [visit(rhs)]);
+        [visit(rhs)],
+        sourceInformationBuilder.buildAssignment(node));
   }
 
   @override
   ir.Primitive visitTypeVariableTypeLiteralSet(
       ast.SendSet node,
       TypeVariableElement element,
       ast.Node rhs, _) {
     return irBuilder.buildStaticNoSuchMethod(
-        new Selector.setter(element.memberName), [visit(rhs)]);
+        new Selector.setter(element.memberName), [visit(rhs)],
+        sourceInformationBuilder.buildAssignment(node));
   }
 
   @override
   ir.Primitive visitDynamicTypeLiteralSet(
       ast.SendSet node,
       ConstantExpression constant,
       ast.Node rhs, _) {
     return irBuilder.buildStaticNoSuchMethod(
-        new Selector.setter(Names.dynamic_), [visit(rhs)]);
+        new Selector.setter(Names.dynamic_), [visit(rhs)],
+        sourceInformationBuilder.buildAssignment(node));
   }
 
   @override
   ir.Primitive visitAbstractClassConstructorInvoke(
       ast.NewExpression node,
       ConstructorElement element,
       InterfaceType type,
       ast.NodeList arguments,
       CallStructure callStructure, _) {
     for (ast.Node argument in arguments) visit(argument);
     ir.Primitive name =
         irBuilder.buildStringConstant(element.enclosingClass.name);
     return irBuilder.buildStaticFunctionInvocation(
         helpers.throwAbstractClassInstantiationError,
-        <ir.Primitive>[name]);
+        <ir.Primitive>[name],
+        sourceInformationBuilder.buildNew(node));
   }
 
   @override
   ir.Primitive handleFinalStaticFieldSet(
       ast.SendSet node,
       FieldElement field,
       ast.Node rhs, _) {
     // TODO(asgerf): Include class name somehow for static class members?
     return irBuilder.buildStaticNoSuchMethod(
         new Selector.setter(field.memberName),
-        [visit(rhs)]);
+        [visit(rhs)],
+        sourceInformationBuilder.buildAssignment(node));
   }
 
   @override
   ir.Primitive visitFinalSuperFieldSet(
       ast.SendSet node,
       FieldElement field,
       ast.Node rhs, _) {
     return buildSuperNoSuchMethod(
         new Selector.setter(field.memberName),
         elements.getTypeMask(node),
-        [visit(rhs)]);
+        [visit(rhs)],
+        sourceInformationBuilder.buildAssignment(node));
   }
 
   @override
   ir.Primitive handleImmutableLocalSet(
       ast.SendSet node,
       LocalElement local,
       ast.Node rhs, _) {
     return irBuilder.buildStaticNoSuchMethod(
         new Selector.setter(new Name(local.name, local.library)),
-        [visit(rhs)]);
+        [visit(rhs)],
+        sourceInformationBuilder.buildAssignment(node));
   }
 
   @override
   ir.Primitive handleStaticFunctionSet(
       ast.Send node,
       MethodElement function,
       ast.Node rhs,
       _) {
     return irBuilder.buildStaticNoSuchMethod(
         new Selector.setter(function.memberName),
-        [visit(rhs)]);
+        [visit(rhs)],
+        sourceInformationBuilder.buildAssignment(node));
   }
 
   @override
   ir.Primitive handleStaticGetterSet(
       ast.SendSet node,
       GetterElement getter,
       ast.Node rhs,
       _) {
     return irBuilder.buildStaticNoSuchMethod(
         new Selector.setter(getter.memberName),
-        [visit(rhs)]);
+        [visit(rhs)],
+        sourceInformationBuilder.buildAssignment(node));
   }
 
   @override
   ir.Primitive handleStaticSetterGet(
       ast.Send node,
       SetterElement setter,
       _) {
     return irBuilder.buildStaticNoSuchMethod(
         new Selector.getter(setter.memberName),
-        []);
+        [],
+        sourceInformationBuilder.buildGet(node));
   }
 
   @override
   ir.Primitive handleStaticSetterInvoke(
       ast.Send node,
       SetterElement setter,
       ast.NodeList argumentsNode,
       CallStructure callStructure, _) {
     // Translate as a method call.
     List<ir.Primitive> arguments = argumentsNode.nodes.mapToList(visit);
     return irBuilder.buildStaticNoSuchMethod(
         new Selector.call(setter.memberName, callStructure),
-        arguments);
+        arguments,
+        sourceInformationBuilder.buildCall(node, argumentsNode));
   }
 
   @override
   ir.Primitive visitSuperGetterSet(
       ast.SendSet node,
       GetterElement getter,
       ast.Node rhs,
       _) {
     return buildSuperNoSuchMethod(
         new Selector.setter(getter.memberName),
         elements.getTypeMask(node),
-        [visit(rhs)]);
+        [visit(rhs)],
+        sourceInformationBuilder.buildAssignment(node));
   }
 
   @override
   ir.Primitive visitSuperMethodSet(
       ast.Send node,
       MethodElement method,
       ast.Node rhs,
       _) {
     return buildSuperNoSuchMethod(
         new Selector.setter(method.memberName),
         elements.getTypeMask(node),
-        [visit(rhs)]);
+        [visit(rhs)],
+        sourceInformationBuilder.buildAssignment(node));
   }
 
   @override
   ir.Primitive visitSuperSetterGet(
       ast.Send node,
       SetterElement setter, _) {
     return buildSuperNoSuchMethod(
-        new Selector.setter(setter.memberName),
+        new Selector.getter(setter.memberName),

[Siggi Cherem (dart-lang), 2016/03/10 17:49:04]

oh my - did this affect any tests? Maybe we should move this change to a
separate CL so that if for any reason we have to roll back some changes here, we
don't roll back this piece?

[Johnni Winther, 2016/03/11 13:46:27]

Removed from this CL.

         elements.getTypeMask(node),
-        []);
+        [],
+        sourceInformationBuilder.buildGet(node));
   }
 
   @override
   ir.Primitive visitSuperSetterInvoke(
       ast.Send node,
       SetterElement setter,
       ast.NodeList argumentsNode,
       CallStructure callStructure, _) {
     List<ir.Primitive> arguments = <ir.Primitive>[];
     callStructure =
         translateDynamicArguments(argumentsNode, callStructure, arguments);
     return buildSuperNoSuchMethod(
         new Selector.call(setter.memberName, callStructure),
         elements.getTypeMask(node),
-        arguments);
+        arguments,
+        sourceInformationBuilder.buildCall(node, argumentsNode));
   }
 
   ir.FunctionDefinition nullIfGiveup(ir.FunctionDefinition action()) {
     try {
       return action();
     } catch(e) {
       if (e == ABORT_IRNODE_BUILDER) {
         return null;
       }
       rethrow;
@@ skipping 251 matching lines @@
     _backend.jsInteropAnalysis.hasAnonymousAnnotation(element.contextClass);
 
   String getJsInteropTargetPath(FunctionElement element) {
     return '${_backend.namer.fixedBackendPath(element)}.'
       '${_backend.getFixedBackendName(element)}';
   }
 
   DartType get jsJavascriptObjectType =>
     _backend.helpers.jsJavaScriptObjectClass.thisType;
 }