Attach source map positions to returns, sends, and some operators.

lib/compiler/implementation/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.
 
 class Interceptors {
   Compiler compiler;
   Interceptors(Compiler this.compiler);
 
   SourceString mapOperatorToMethodName(Operator op) {
     String name = op.source.stringValue;
@@ skipping 1147 matching lines @@
     HBasicBlock newBlock = addNewBlock();
     if (!isAborted()) goto(current, newBlock);
     open(newBlock);
     return newBlock;
   }
 
   void add(HInstruction instruction) {
     current.add(instruction);
   }
 
+  void addWithPosition(HInstruction instruction, Node node) {
+    add(attachPosition(instruction, node));
+  }
+
   void push(HInstruction instruction) {
     add(instruction);
     stack.add(instruction);
   }
 
+  void pushWithPosition(HInstruction instruction, Node node) {
+    push(attachPosition(instruction, node));
+  }
+
   HInstruction pop() {
     return stack.removeLast();
   }
 
   void dup() {
     stack.add(stack.last());
   }
 
   HBoolify popBoolified() {
     HBoolify boolified = new HBoolify(pop());
@@ skipping 400 matching lines @@
         node.receiver,
         () { visit(node.argumentsNode); },
         isAnd: (const SourceString("&&") == op.source));
   }
 
 
   void visitLogicalNot(Send node) {
     assert(node.argumentsNode is Prefix);
     visit(node.receiver);
     HNot not = new HNot(popBoolified());
-    push(not);
+    pushWithPosition(not, node);
   }
 
   void visitUnary(Send node, Operator op) {
     assert(node.argumentsNode is Prefix);
     visit(node.receiver);
     assert(op.token.kind !== PLUS_TOKEN);
     HInstruction operand = pop();
 
-    HInstruction target = attachPosition(
-        new HStatic(interceptors.getPrefixOperatorInterceptor(op)), node);
+    HInstruction target =
+        new HStatic(interceptors.getPrefixOperatorInterceptor(op));
     add(target);
     HInvokeUnary result;
     String value = op.source.stringValue;
     switch (value) {
       case "-": result = new HNegate(target, operand); break;
       case "~": result = new HBitNot(target, operand); break;
       default:
         compiler.internalError('Unexpected unary operator: $value.', node: op);
         break;
     }
     // See if we can constant-fold right away. This avoids rewrites later on.
     if (operand is HConstant) {
       HConstant constant = operand;
       Constant folded = result.operation.fold(constant.constant);
       if (folded !== null) {
         stack.add(graph.addConstant(folded));
         return;
       }
     }
-    push(result);
+    pushWithPosition(result, node);
   }
 
   void visitBinary(HInstruction left, Operator op, HInstruction right) {
     Element element = interceptors.getOperatorInterceptor(op);
     assert(element != null);
     HInstruction target = new HStatic(element);
     add(target);
     switch (op.source.stringValue) {
       case "+":
       case "++":
       case "+=":
-        push(new HAdd(target, left, right));
+        pushWithPosition(new HAdd(target, left, right), op);
         break;
       case "-":
       case "--":
       case "-=":
-        push(new HSubtract(target, left, right));
+        pushWithPosition(new HSubtract(target, left, right), op);
         break;
       case "*":
       case "*=":
-        push(new HMultiply(target, left, right));
+        pushWithPosition(new HMultiply(target, left, right), op);
         break;
       case "/":
       case "/=":
-        push(new HDivide(target, left, right));
+        pushWithPosition(new HDivide(target, left, right), op);
         break;
       case "~/":
       case "~/=":
-        push(new HTruncatingDivide(target, left, right));
+        pushWithPosition(new HTruncatingDivide(target, left, right), op);
         break;
       case "%":
       case "%=":
-        push(new HModulo(target, left, right));
+        pushWithPosition(new HModulo(target, left, right), op);
         break;
       case "<<":
       case "<<=":
-        push(new HShiftLeft(target, left, right));
+        pushWithPosition(new HShiftLeft(target, left, right), op);
         break;
       case ">>":
       case ">>=":
-        push(new HShiftRight(target, left, right));
+        pushWithPosition(new HShiftRight(target, left, right), op);
         break;
       case "|":
       case "|=":
-        push(new HBitOr(target, left, right));
+        pushWithPosition(new HBitOr(target, left, right), op);
         break;
       case "&":
       case "&=":
-        push(new HBitAnd(target, left, right));
+        pushWithPosition(new HBitAnd(target, left, right), op);
         break;
       case "^":
       case "^=":
-        push(new HBitXor(target, left, right));
+        pushWithPosition(new HBitXor(target, left, right), op);
         break;
       case "==":
-        push(new HEquals(target, left, right));
+        pushWithPosition(new HEquals(target, left, right), op);
         break;
       case "===":
-        push(new HIdentity(target, left, right));
+        pushWithPosition(new HIdentity(target, left, right), op);
         break;
       case "!==":
         HIdentity eq = new HIdentity(target, left, right);
         add(eq);
-        push(new HNot(eq));
+        pushWithPosition(new HNot(eq), op);
         break;
       case "<":
-        push(new HLess(target, left, right));
+        pushWithPosition(new HLess(target, left, right), op);
         break;
       case "<=":
-        push(new HLessEqual(target, left, right));
+        pushWithPosition(new HLessEqual(target, left, right), op);
         break;
       case ">":
-        push(new HGreater(target, left, right));
+        pushWithPosition(new HGreater(target, left, right), op);
         break;
       case ">=":
-        push(new HGreaterEqual(target, left, right));
+        pushWithPosition(new HGreaterEqual(target, left, right), op);
         break;
       case "!=":
         HEquals eq = new HEquals(target, left, right);
         add(eq);
         HBoolify bl = new HBoolify(eq);
         add(bl);
-        push(new HNot(bl));
+        pushWithPosition(new HNot(bl), op);
         break;
       default: compiler.unimplemented("SsaBuilder.visitBinary");
     }
   }
 
   HInstruction generateInstanceSendReceiver(Send send) {
     assert(Elements.isInstanceSend(send, elements));
     if (send.receiver == null) {
       return localsHandler.readThis();
     }
@@ skipping 288 matching lines @@
     if (node.receiver === null) {
       inputs.add(localsHandler.readThis());
     } else {
       visit(node.receiver);
       inputs.add(pop());
     }
 
     addDynamicSendArgumentsToList(node, inputs);
 
     // The first entry in the inputs list is the receiver.
-    push(new HInvokeDynamicMethod(selector, dartMethodName, inputs));
+    pushWithPosition(new HInvokeDynamicMethod(selector, dartMethodName, inputs),
+                     node);
 
     if (isNotEquals) {
       HNot not = new HNot(popBoolified());
       push(not);
     }
   }
 
   visitClosureSend(Send node) {
     Selector selector = elements.getSelector(node);
     assert(node.receiver === null);
     Element element = elements[node];
     HInstruction closureTarget;
     if (element === null) {
       visit(node.selector);
       closureTarget = pop();
     } else {
       assert(Elements.isLocal(element));
       closureTarget = localsHandler.readLocal(element);
     }
     var inputs = <HInstruction>[];
     inputs.add(closureTarget);
     addDynamicSendArgumentsToList(node, inputs);
-    push(new HInvokeClosure(selector, inputs));
+    pushWithPosition(new HInvokeClosure(selector, inputs), node);
   }
 
   void handleForeignJs(Send node) {
     Link<Node> link = node.arguments;
     // If the invoke is on foreign code, don't visit the first
     // argument, which is the type, and the second argument,
     // which is the foreign code.
     if (link.isEmpty() || link.isEmpty()) {
       compiler.cancel('At least two arguments expected',
                       node: node.argumentsNode);
@@ skipping 227 matching lines @@
     bool succeeded = addStaticSendArgumentsToList(selector, node.arguments,
                                                   element, inputs);
     if (!succeeded) {
       // TODO(ngeoffray): Match the VM behavior and throw an
       // exception at runtime.
       compiler.cancel('Unimplemented non-matching static call', node: node);
     }
 
     HType elementType = computeType(element);
     HInstruction newInstance = new HInvokeStatic(selector, inputs, elementType);
-    push(newInstance);
+    pushWithPosition(newInstance, node);
 
     TypeAnnotation annotation = getTypeAnnotationFromSend(node);
     Type type = elements.getType(annotation);
     generateSetRuntimeTypeInformation(newInstance, type);
   }
 
   generateSetRuntimeTypeInformation(HInstruction instance, Type type) {
     if (compiler.codegenWorld.rti.hasTypeArguments(type)) {
       String typeString = compiler.codegenWorld.rti.asJsString(type);
       HInstruction typeInfo = new HForeign(new LiteralDartString(typeString),
@@ skipping 22 matching lines @@
     var inputs = <HInstruction>[];
     inputs.add(target);
     if (element.kind == ElementKind.FUNCTION) {
       bool succeeded = addStaticSendArgumentsToList(selector, node.arguments,
                                                     element, inputs);
       if (!succeeded) {
         // TODO(ngeoffray): Match the VM behavior and throw an
         // exception at runtime.
         compiler.cancel('Unimplemented non-matching static call', node: node);
       }
-      push(new HInvokeStatic(selector, inputs));
+      pushWithPosition(new HInvokeStatic(selector, inputs), node);
     } else {
       if (element.kind == ElementKind.GETTER) {
         target = new HInvokeStatic(Selector.GETTER, inputs);
         add(target);
         inputs = <HInstruction>[target];
       }
       addDynamicSendArgumentsToList(node, inputs);
-      push(new HInvokeClosure(selector, inputs));
+      pushWithPosition(new HInvokeClosure(selector, inputs), node);
     }
   }
 
   visitGetterSend(Send node) {
     generateGetter(node, elements[node]);
   }
 
   // TODO(antonm): migrate rest of SsaBuilder to internalError.
   internalError(String reason, [Node node]) {
     compiler.internalError(reason, node: node);
@@ skipping 199 matching lines @@
       native.handleSsaNative(this, node.expression);
       return;
     }
     HInstruction value;
     if (node.expression === null) {
       value = graph.addConstantNull();
     } else {
       visit(node.expression);
       value = pop();
     }
-    close(new HReturn(value)).addSuccessor(graph.exit);
+    close(attachPosition(new HReturn(value), node)).addSuccessor(graph.exit);
   }
 
   visitThrow(Throw node) {
     if (node.expression === null) {
       HInstruction exception = rethrowableException;
       if (exception === null) {
         exception = graph.addConstantNull();
         compiler.reportError(node,
                              'throw without expression outside catch block');
       }
@@ skipping 1006 matching lines @@
           new HSubGraphBlockInformation(elseBranch.graph));
 
     HBasicBlock conditionStartBlock = conditionBranch.block;
     conditionStartBlock.setBlockFlow(info, joinBlock);
     SubGraph conditionGraph = conditionBranch.graph;
     HIf branch = conditionGraph.end.last;
     assert(branch is HIf);
     branch.blockInformation = conditionStartBlock.blockFlow;
   }
 }