Add locations to diagnostics.

dart/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 659 matching lines @@
   void close();
   final TargetElement target;
   List<LabelElement> labels();
 }
 
 // Insert break handler used to avoid null checks when a target isn't
 // used as the target of a break, and therefore doesn't need a break
 // handler associated with it.
 class NullJumpHandler implements JumpHandler {
   const NullJumpHandler();
-  void generateBreak([LabelElement label]) { unreachable(); }
-  void generateContinue([LabelElement label]) { unreachable(); }
+
+  void generateBreak([LabelElement label]) {
+    // TODO(lrn): Need a compiler object and a location. Since label
+    // is optional, it may be null so we also need a position.
+    compiler.internalError('generateBreak should not be called',
+                           missingPosition);
+  }
+
+  void generateContinue([LabelElement label]) {
+    // TODO(lrn): Need a compiler object and a location. Since label
+    // is optional, it may be null so we also need a position.
+    compiler.internalError('generateContinue should not be called',
+                           missingPosition);
+  }
+
   void forEachBreak(Function ignored) { }
   void forEachContinue(Function ignored) { }
   void close() { }
   final TargetElement target = null;
   List<LabelElement> labels() => const <LabelElement>[];
 }
 
 // Records breaks until a target block is available.
 // Breaks are always forward jumps.
 // Continues in loops are implemented as breaks of the body.
@@ skipping 451 matching lines @@
         // The block has been aborted by a return or a throw.
         if (!stack.isEmpty()) compiler.cancel('non-empty instruction stack');
         return;
       }
     }
     assert(!current.isClosed());
     if (!stack.isEmpty()) compiler.cancel('non-empty instruction stack');
   }
 
   visitClassNode(ClassNode node) {
-    unreachable();
+    compiler.internalError('visitClassNode should not be called', node: node);
   }
 
   visitExpressionStatement(ExpressionStatement node) {
     visit(node.expression);
     pop();
   }
 
   /**
    * Creates a new loop-header block. The previous [current] block
    * is closed with an [HGoto] and replaced by the newly created block.
@@ skipping 489 matching lines @@
   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 =
         new HStatic(interceptors.getPrefixOperatorInterceptor(op));
     add(target);
     HInvokeUnary result;
-    switch (op.source.stringValue) {
+    String value = op.source.stringValue;
+    switch (value) {
       case "-": result = new HNegate(target, operand); break;
       case "~": result = new HBitNot(target, operand); break;
-      default: unreachable();
+      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;
       }
     }
@@ skipping 564 matching lines @@
       HStatic target = new HStatic(element);
       add(target);
       HInstruction self = localsHandler.readThis();
       Identifier identifier = node.selector.asIdentifier();
       String name = identifier.source.slowToString();
       // TODO(ahe): Add the arguments to this list.
       push(new HLiteralList([]));
       var inputs = <HInstruction>[
           target,
           self,
-          graph.addConstantString(new DartString.literal(name)),
+          graph.addConstantString(new DartString.literal(name), node),
           pop()];
       push(new HInvokeSuper(Selector.INVOCATION_2, inputs));
       return;
     }
     HInstruction target = new HStatic(element);
     HInstruction context = localsHandler.readThis();
     add(target);
     var inputs = <HInstruction>[target, context];
     if (element.kind == ElementKind.FUNCTION ||
         element.kind == ElementKind.GENERATIVE_CONSTRUCTOR) {
@@ skipping 269 matching lines @@
 
   void visitLiteralDouble(LiteralDouble node) {
     stack.add(graph.addConstantDouble(node.value));
   }
 
   void visitLiteralBool(LiteralBool node) {
     stack.add(graph.addConstantBool(node.value));
   }
 
   void visitLiteralString(LiteralString node) {
-    stack.add(graph.addConstantString(node.dartString));
+    stack.add(graph.addConstantString(node.dartString, node));
   }
 
   void visitStringJuxtaposition(StringJuxtaposition node) {
     if (!node.isInterpolation) {
       // This is a simple string with no interpolations.
-      stack.add(graph.addConstantString(node.dartString));
+      stack.add(graph.addConstantString(node.dartString, node));
       return;
     }
     int offset = node.getBeginToken().charOffset;
     StringBuilderVisitor stringBuilder =
         new StringBuilderVisitor(this, offset);
     stringBuilder.visit(node);
-    stack.add(stringBuilder.result());
+    stack.add(stringBuilder.result(node));
   }
 
   void visitLiteralNull(LiteralNull node) {
     stack.add(graph.addConstantNull());
   }
 
   visitNodeList(NodeList node) {
     for (Link<Node> link = node.nodes; !link.isEmpty(); link = link.tail) {
       if (isAborted()) {
         compiler.reportWarning(link.head, 'dead code');
       } else {
         visit(link.head);
       }
     }
   }
 
   void visitParenthesizedExpression(ParenthesizedExpression node) {
     visit(node.expression);
   }
 
   visitOperator(Operator node) {
     // Operators are intercepted in their surrounding Send nodes.
-    unreachable();
+    compiler.internalError('visitOperator should not be called', node: node);
   }
 
   visitCascade(Cascade node) {
     visit(node.expression);
     // Remove the result and reveal the duplicated receiver on the stack.
     pop();
   }
 
   visitCascadeReceiver(CascadeReceiver node) {
     visit(node.expression);
@@ skipping 110 matching lines @@
         <HInstruction>[thenInstruction, elseInstruction]);
     joinBlock.addPhi(phi);
     stack.add(phi);
   }
 
   visitStringInterpolation(StringInterpolation node) {
     int offset = node.getBeginToken().charOffset;
     StringBuilderVisitor stringBuilder =
         new StringBuilderVisitor(this, offset);
     stringBuilder.visit(node);
-    stack.add(stringBuilder.result());
+    stack.add(stringBuilder.result(node));
   }
 
   visitStringInterpolationPart(StringInterpolationPart node) {
     // The parts are iterated in visitStringInterpolation.
-    unreachable();
+    compiler.internalError('visitStringInterpolation should not be called',
+                           node: node);
   }
 
   visitEmptyStatement(EmptyStatement node) {
     // Do nothing, empty statement.
   }
 
   visitModifiers(Modifiers node) {
     compiler.unimplemented('SsaBuilder.visitModifiers', node: node);
   }
 
@@ skipping 439 matching lines @@
   }
 
   visitTypedef(Typedef node) {
     compiler.unimplemented('SsaBuilder.visitTypedef', node: node);
   }
 
   visitTypeVariable(TypeVariable node) {
     compiler.internalError('SsaBuilder.visitTypeVariable');
   }
 
-  generateUnimplemented(String reason, [bool isExpression = false]) {
-    DartString string = new DartString.literal(reason);
-    HInstruction message = graph.addConstantString(string);
-
-    // Normally, we would call [close] here. However, then we hit
-    // another unimplemented feature: aborting loop body. Simply
-    // calling [add] does not work as it asserts that the instruction
-    // isn't a control flow instruction. So we inline parts of [add].
-    current.addAfter(current.last, new HThrow(message));
-    if (isExpression) {
-      stack.add(graph.addConstantNull());
-    }
-  }
-
   /** HACK HACK HACK */
   void hackAroundPossiblyAbortingBody(Node statement, void body()) {
     visitCondition() {
       stack.add(graph.addConstantBool(true));
     }
     buildBody() {
       // TODO(lrn): Make sure to take continue into account.
       body();
     }
     handleIf(visitCondition, buildBody, null);
@@ skipping 39 matching lines @@
 
   void visit(Node node) {
     node.accept(this);
   }
 
   visitNode(Node node) {
     builder.compiler.internalError('unexpected node', node: node);
   }
 
   void visitExpression(Node node) {
-    flushLiterals();
+    flushLiterals(node);
     node.accept(builder);
     HInstruction asString = buildToString(node, builder.pop());
     prefix = buildConcat(prefix, asString);
   }
 
   void visitLiteralNull(LiteralNull node) {
     addLiteral(const LiteralDartString("null"));
   }
 
   void visitLiteralInt(LiteralInt node) {
@@ skipping 34 matching lines @@
    * Add another literal string to the literalAccumulator.
    */
   void addLiteral(DartString dartString) {
     literalAccumulator = new DartString.concat(literalAccumulator, dartString);
   }
 
   /**
    * Combine the strings in [literalAccumulator] into the prefix instruction.
    * After this, the [literalAccumulator] is empty and [prefix] is non-null.
    */
-  void flushLiterals() {
+  void flushLiterals(Node node) {
     if (literalAccumulator.isEmpty()) {
       if (prefix === null) {
-        prefix = builder.graph.addConstantString(literalAccumulator);
+        prefix = builder.graph.addConstantString(literalAccumulator, node);
       }
       return;
     }
-    HInstruction string = builder.graph.addConstantString(literalAccumulator);
+    HInstruction string =
+        builder.graph.addConstantString(literalAccumulator, node);
     literalAccumulator = new DartString.empty();
     if (prefix !== null) {
       prefix = buildConcat(prefix, string);
     } else {
       prefix = string;
     }
   }
 
   HInstruction buildConcat(HInstruction left, HInstruction right) {
     HStatic target = new HStatic(stringConcat);
     builder.add(target);
     builder.push(new HAdd(target, left, right));
     return builder.pop();
   }
 
   HInstruction buildToString(Node node, HInstruction input) {
     HStatic target = new HStatic(stringToString);
     builder.add(target);
     builder.push(new HInvokeStatic(Selector.INVOCATION_1,
                                    <HInstruction>[target, input],
                                    HType.STRING));
     return builder.pop();
   }
 
-  HInstruction result() {
-    flushLiterals();
+  HInstruction result(Node node) {
+    flushLiterals(node);
     return prefix;
   }
 }