Use failedAt in more places

pkg/compiler/lib/src/ssa/codegen.dart

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 import 'dart:math' as math;
 import 'dart:collection' show Queue;
 import '../common.dart';
 import '../common/codegen.dart' show CodegenRegistry, CodegenWorkItem;
 import '../common/tasks.dart' show CompilerTask;
 import '../constants/constant_system.dart';
@@ skipping 1065 matching lines @@
             }
             body.statements.add(new js.If(jsCondition, updateBody, exitLoop));
             jsCondition = newLiteralBool(true, info.sourceInformation);
           }
           loop = new js.Do(unwrapStatement(body), jsCondition)
               .withSourceInformation(info.sourceInformation);
         }
         currentContainer = oldContainer;
         break;
       default:
-        throw new SpannableAssertionFailure(condition.conditionExpression,
+        failedAt(condition.conditionExpression,
             'Unexpected loop kind: ${info.kind}.');
     }
     js.Statement result = loop;
     if (info.kind == HLoopBlockInformation.SWITCH_CONTINUE_LOOP) {
       String continueLabelString =
           _namer.implicitContinueLabelName(info.target);
       result = new js.LabeledStatement(continueLabelString, result);
     }
     pushStatement(wrapIntoLabels(result, info.labels));
     return true;
@@ skipping 393 matching lines @@
     HBasicBlock block = node.block;
     assert(block.successors.length == 1);
     List<HBasicBlock> dominated = block.dominatedBlocks;
     // With the exception of the entry-node which dominates its successor
     // and the exit node, no block finishing with a 'goto' can have more than
     // one dominated block (since it has only one successor).
     // If the successor is dominated by another block, then the other block
     // is responsible for visiting the successor.
     if (dominated.isEmpty) return;
     if (dominated.length > 2) {
-      throw new SpannableAssertionFailure(
-          node, 'dominated.length = ${dominated.length}');
+      failedAt(node, 'dominated.length = ${dominated.length}');
     }
     if (dominated.length == 2 && block != currentGraph.entry) {
-      throw new SpannableAssertionFailure(
-          node, 'node.block != currentGraph.entry');
+      failedAt(node, 'node.block != currentGraph.entry');
     }
     assert(dominated[0] == block.successors[0]);
     continueSubGraph(dominated.first);
   }
 
   visitLoopBranch(HLoopBranch node) {
     assert(node.block == subGraph.end);
     // We are generating code for a loop condition.
     // If we are generating the subgraph as an expression, the
     // condition will be generated as the expression.
@@ skipping 67 matching lines @@
     // try/catch block, ie the try body is always a predecessor
     // of the catch and finally. Here, we continue visiting the try
     // body by visiting the block that contains the user-level control
     // flow instruction.
     continueSubGraph(node.bodyTrySuccessor);
   }
 
   visitTry(HTry node) {
     // We should never get here. Try/catch/finally is always handled using block
     // information in [visitTryInfo].
-    throw new SpannableAssertionFailure(node, 'visitTry should not be called.');
+    failedAt(node, 'visitTry should not be called.');
   }
 
   bool tryControlFlowOperation(HIf node) {
     if (!controlFlowOperators.contains(node)) return false;
     HPhi phi = node.joinBlock.phis.first;
     bool atUseSite = isGenerateAtUseSite(phi);
     // Don't generate a conditional operator in this situation:
     // i = condition ? bar() : i;
     // But generate this instead:
     // if (condition) i = bar();
@@ skipping 1286 matching lines @@
       return pop();
     } else if (checkedType.containsOnlyBool(_closedWorld)) {
       // input is !bool
       checkBool(input, '!==', input.sourceInformation);
       return pop();
     } else if (checkedType.containsOnlyString(_closedWorld)) {
       // input is !string
       checkString(input, '!==', input.sourceInformation);
       return pop();
     }
-    throw new SpannableAssertionFailure(
-        input, 'Unexpected check: $checkedType.');
+    throw failedAt(input, 'Unexpected check: $checkedType.');
   }
 
   void visitTypeConversion(HTypeConversion node) {
     if (node.isArgumentTypeCheck || node.isReceiverTypeCheck) {
       js.Expression test = generateReceiverOrArgumentTypeTest(node);
       js.Block oldContainer = currentContainer;
       js.Statement body = new js.Block.empty();
       currentContainer = body;
       if (node.isArgumentTypeCheck) {
         generateThrowWithHelper(
@@ skipping 129 matching lines @@
     return _closedWorld.anyStrictSubclassOf(cls, (ClassEntity subclass) {
       return !_rtiSubstitutions.isTrivialSubstitution(subclass, cls);
     });
   }
 
   @override
   void visitRef(HRef node) {
     visit(node.value);
   }
 }