Remove cancel and make crash exit with code 253.

sdk/lib/_internal/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.
 
 part of ssa;
 
 /**
  * A special element for the extra parameter taken by intercepted
  * methods. We need to implement [TypedElement.type] because our
  * optimizers may look at its declared type.
@@ skipping 36 matching lines @@
                    kind == ElementKind.SETTER) {
           graph = builder.buildMethod(element);
         } else if (kind == ElementKind.FIELD) {
           if (element.isInstanceMember()) {
             assert(compiler.enableTypeAssertions);
             graph = builder.buildCheckedSetter(element);
           } else {
             graph = builder.buildLazyInitializer(element);
           }
         } else {
-          compiler.internalErrorOnElement(element,
-                                          'unexpected element kind $kind');
+          compiler.internalError(element, 'Unexpected element kind $kind.');
         }
         assert(graph.isValid());
         if (!identical(kind, ElementKind.FIELD)) {
           FunctionElement function = element;
           FunctionSignature signature = function.functionSignature;
           signature.forEachOptionalParameter((Element parameter) {
             // This ensures the default value will be computed.
             Constant constant =
                 compiler.constantHandler.getConstantForVariable(parameter);
             backend.registerCompileTimeConstant(constant, work.resolutionTree);
@@ skipping 280 matching lines @@
 
   /**
    * Returns an [HInstruction] for the given element. If the element is
    * boxed or stored in a closure then the method generates code to retrieve
    * the value.
    */
   HInstruction readLocal(Element element) {
     if (isAccessedDirectly(element)) {
       if (directLocals[element] == null) {
         if (element.isTypeVariable()) {
-          builder.compiler.internalError(
-              "Runtime type information not available for $element",
-              element: builder.compiler.currentElement);
+          builder.compiler.internalError(builder.compiler.currentElement,
+              "Runtime type information not available for $element.");
         } else {
-          builder.compiler.internalError(
-              "Cannot find value $element",
-              element: element);
+          builder.compiler.internalError(element,
+              "Cannot find value $element.");
         }
       }
       return directLocals[element];
     } else if (isStoredInClosureField(element)) {
       Element redirect = redirectionMapping[element];
       HInstruction receiver = readLocal(closureData.closureElement);
       TypeMask type = (element.kind == ElementKind.VARIABLE_LIST)
           ? builder.backend.nonNullType
           : builder.getTypeOfCapturedVariable(redirect);
       assert(element.kind != ElementKind.VARIABLE_LIST
@@ skipping 313 matching lines @@
 
 // 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 {
   final Compiler compiler;
 
   NullJumpHandler(this.compiler);
 
   void generateBreak([LabelElement label]) {
-    compiler.internalError('generateBreak should not be called');
+    compiler.internalError(CURRENT_ELEMENT_SPANNABLE,
+        'NullJumpHandler.generateBreak should not be called.');
   }
 
   void generateContinue([LabelElement label]) {
-    compiler.internalError('generateContinue should not be called');
+    compiler.internalError(CURRENT_ELEMENT_SPANNABLE,
+        'NullJumpHandler.generateContinue should not be called.');
   }
 
   void forEachBreak(Function ignored) { }
   void forEachContinue(Function ignored) { }
   void close() { }
   bool hasAnyContinue() => false;
   bool hasAnyBreak() => false;
 
   List<LabelElement> labels() => const <LabelElement>[];
   TargetElement get target => null;
@@ skipping 1075 matching lines @@
       ClassElement enclosingClass = constructor.getEnclosingClass();
       ClassElement superClass = enclosingClass.superclass;
       if (!enclosingClass.isObject(compiler)) {
         assert(superClass != null);
         assert(superClass.resolutionState == STATE_DONE);
         Selector selector =
             new Selector.callDefaultConstructor(enclosingClass.getLibrary());
         // TODO(johnniwinther): Should we find injected constructors as well?
         FunctionElement target = superClass.lookupConstructor(selector);
         if (target == null) {
-          compiler.internalError("no default constructor available");
+          compiler.internalError(superClass,
+              "No default constructor available.");
         }
         List<HInstruction> arguments = <HInstruction>[];
         selector.addArgumentsToList(const Link<ast.Node>(),
                                     arguments,
                                     target.implementation,
                                     null,
                                     handleConstantForOptionalParameter,
                                     compiler);
         inlineSuperOrRedirect(target,
                               arguments,
@@ skipping 464 matching lines @@
 
   visitBlock(ast.Block node) {
     assert(!isAborted());
     if (!isReachable) return;  // This can only happen when inlining.
     for (Link<ast.Node> link = node.statements.nodes;
          !link.isEmpty;
          link = link.tail) {
       visit(link.head);
       if (!isReachable) {
         // The block has been aborted by a return or a throw.
-        if (!stack.isEmpty) compiler.cancel('non-empty instruction stack');
+        if (!stack.isEmpty) {
+          compiler.internalError(node, 'Non-empty instruction stack.');
+        }
         return;
       }
     }
     assert(!current.isClosed());
-    if (!stack.isEmpty) compiler.cancel('non-empty instruction stack');
+    if (!stack.isEmpty) {
+      compiler.internalError(node, 'Non-empty instruction stack.');
+    }
   }
 
   visitClassNode(ast.ClassNode node) {
-    compiler.internalError('visitClassNode should not be called', node: node);
+    compiler.internalError(node,
+        'SsaBuilder.visitClassNode should not be called.');
   }
 
   visitThrowExpression(ast.Expression expression) {
     bool old = inThrowExpression;
     try {
       inThrowExpression = true;
       visit(expression);
     } finally {
       inThrowExpression = old;
     }
@@ skipping 506 matching lines @@
   visitFunctionDeclaration(ast.FunctionDeclaration node) {
     assert(isReachable);
     visit(node.function);
     localsHandler.updateLocal(elements[node], pop());
   }
 
   visitIdentifier(ast.Identifier node) {
     if (node.isThis()) {
       stack.add(localsHandler.readThis());
     } else {
-      compiler.internalError("SsaFromAstMixin.visitIdentifier on non-this",
-                             node: node);
+      compiler.internalError(node,
+          "SsaFromAstMixin.visitIdentifier on non-this.");
     }
   }
 
   visitIf(ast.If node) {
     assert(isReachable);
     handleIf(node,
              () => visit(node.condition),
              () => visit(node.thenPart),
              node.elsePart != null ? () => visit(node.elsePart) : null);
   }
@@ skipping 459 matching lines @@
         new HInvokeClosure(closureSelector, inputs, backend.dynamicType),
         node);
   }
 
   void handleForeignJs(ast.Send node) {
     Link<ast.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.tail.isEmpty) {
-      compiler.cancel('At least two arguments expected',
-                      node: node.argumentsNode);
+      compiler.internalError(node.argumentsNode,
+          'At least two arguments expected.');
     }
     native.NativeBehavior nativeBehavior =
         compiler.enqueuer.resolution.nativeEnqueuer.getNativeBehaviorOf(node);
 
     List<HInstruction> inputs = <HInstruction>[];
     addGenericSendArgumentsToList(link.tail.tail, inputs);
 
     TypeMask ssaType =
         TypeMaskFactory.fromNativeBehavior(nativeBehavior, compiler);
     push(new HForeign(nativeBehavior.codeAst, ssaType, inputs,
                       effects: nativeBehavior.sideEffects,
                       nativeBehavior: nativeBehavior));
     return;
   }
 
   void handleForeignJsCurrentIsolateContext(ast.Send node) {
     if (!node.arguments.isEmpty) {
-      compiler.cancel(
-          'Too many arguments to JS_CURRENT_ISOLATE_CONTEXT', node: node);
+      compiler.internalError(node,
+          'Too many arguments to JS_CURRENT_ISOLATE_CONTEXT.');
     }
 
     if (!compiler.hasIsolateSupport()) {
       // If the isolate library is not used, we just generate code
       // to fetch the current isolate.
       String name = backend.namer.currentIsolate;
       push(new HForeign(new js.LiteralString(name),
                         backend.dynamicType,
                         <HInstruction>[]));
     } else {
       // Call a helper method from the isolate library. The isolate
       // library uses its own isolate structure, that encapsulates
       // Leg's isolate.
       Element element = compiler.isolateHelperLibrary.find('_currentIsolate');
       if (element == null) {
-        compiler.cancel(
-            'Isolate library and compiler mismatch', node: node);
+        compiler.internalError(node,
+            'Isolate library and compiler mismatch.');
       }
       pushInvokeStatic(null, element, [], backend.dynamicType);
     }
   }
 
   void handleForeignJsGetName(ast.Send node) {
     List<ast.Node> arguments = node.arguments.toList();
     ast.Node argument;
     switch (arguments.length) {
     case 0:
@@ skipping 54 matching lines @@
       // closure.
       visit(link.tail.head);
       Selector selector = new Selector.callClosure(0);
       push(new HInvokeClosure(selector,
                               <HInstruction>[pop()],
                               backend.dynamicType));
     } else {
       // Call a helper method from the isolate library.
       Element element = compiler.isolateHelperLibrary.find('_callInIsolate');
       if (element == null) {
-        compiler.cancel(
-            'Isolate library and compiler mismatch', node: node);
+        compiler.internalError(node,
+            'Isolate library and compiler mismatch.');
       }
       List<HInstruction> inputs = <HInstruction>[];
       addGenericSendArgumentsToList(link, inputs);
       pushInvokeStatic(node, element, inputs, backend.dynamicType);
     }
   }
 
   FunctionSignature handleForeignRawFunctionRef(ast.Send node, String name) {
     if (node.arguments.isEmpty || !node.arguments.tail.isEmpty) {
-      compiler.cancel('"$name" requires exactly one argument',
-                      node: node.argumentsNode);
+      compiler.internalError(node.argumentsNode,
+          '"$name" requires exactly one argument.');
     }
     ast.Node closure = node.arguments.head;
     Element element = elements[closure];
     if (!Elements.isStaticOrTopLevelFunction(element)) {
-      compiler.cancel(
-          '"$name" requires a static or top-level method',
-          node: closure);
+      compiler.internalError(closure,
+          '"$name" requires a static or top-level method.');
     }
     FunctionElement function = element;
     // TODO(johnniwinther): Try to eliminate the need to distinguish declaration
     // and implementation signatures. Currently it is need because the
     // signatures have different elements for parameters.
     FunctionElement implementation = function.implementation;
     FunctionSignature params = implementation.functionSignature;
     if (params.optionalParameterCount != 0) {
-      compiler.cancel(
-          '"$name" does not handle closure with optional parameters',
-          node: closure);
+      compiler.internalError(closure,
+          '"$name" does not handle closure with optional parameters.');
     }
 
     compiler.enqueuer.codegen.registerStaticUse(element);
     push(new HForeign(backend.namer.elementAccess(element),
                       backend.dynamicType,
                       <HInstruction>[]));
     return params;
   }
 
   void handleForeignDartClosureToJs(ast.Send node, String name) {
     // TODO(ahe): This implements DART_CLOSURE_TO_JS and should probably take
     // care to wrap the closure in another closure that saves the current
     // isolate.
     handleForeignRawFunctionRef(node, name);
   }
 
   void handleForeignSetCurrentIsolate(ast.Send node) {
     if (node.arguments.isEmpty || !node.arguments.tail.isEmpty) {
-      compiler.cancel('Exactly one argument required',
-                      node: node.argumentsNode);
+      compiler.internalError(node.argumentsNode,
+          'Exactly one argument required.');
     }
     visit(node.arguments.head);
     String isolateName = backend.namer.currentIsolate;
     SideEffects sideEffects = new SideEffects.empty();
     sideEffects.setAllSideEffects();
     push(new HForeign(js.js("$isolateName = #"),
                       backend.dynamicType,
                       <HInstruction>[pop()],
                       effects: sideEffects));
   }
 
   void handleForeignCreateIsolate(ast.Send node) {
     if (!node.arguments.isEmpty) {
-      compiler.cancel('Too many arguments',
-                      node: node.argumentsNode);
+      compiler.internalError(node.argumentsNode, 'Too many arguments.');
     }
     String constructorName = backend.namer.isolateName;
     push(new HForeign(js.js("new $constructorName()"),
                       backend.dynamicType,
                       <HInstruction>[]));
   }
 
   void handleForeignDartObjectJsConstructorFunction(ast.Send node) {
     if (!node.arguments.isEmpty) {
-      compiler.cancel('Too many arguments', node: node.argumentsNode);
+      compiler.internalError(node.argumentsNode, 'Too many arguments.');
     }
     String jsClassReference = backend.namer.isolateAccess(compiler.objectClass);
     push(new HForeign(new js.LiteralString(jsClassReference),
                       backend.dynamicType,
                       <HInstruction>[]));
   }
 
   void handleForeignJsCurrentIsolate(ast.Send node) {
     if (!node.arguments.isEmpty) {
-      compiler.cancel('Too many arguments', node: node.argumentsNode);
+      compiler.internalError(node.argumentsNode, 'Too many arguments.');
     }
     push(new HForeign(new js.LiteralString(backend.namer.currentIsolate),
                       backend.dynamicType,
                       <HInstruction>[]));
   }
 
   visitForeignSend(ast.Send node) {
     Selector selector = elements.getSelector(node);
     String name = selector.name;
     if (name == 'JS') {
@@ skipping 246 matching lines @@
                (member.isField() && !isBuildingFor(member))) {
       // The type variable is stored in a parameter of the method.
       return localsHandler.readLocal(type.element);
     } else if (member.isInstanceMember()) {
       // The type variable is stored on the object.
       return readTypeVariable(member.getEnclosingClass(),
                               type.element);
     } else {
       // TODO(ngeoffray): Match the VM behavior and throw an
       // exception at runtime.
-      compiler.cancel('Unimplemented unresolved type variable',
-                      element: type.element);
+      compiler.internalError(type.element,
+          'Unimplemented unresolved type variable.');
       return null;
     }
   }
 
   HInstruction analyzeTypeArgument(DartType argument) {
     if (argument.treatAsDynamic) {
       // Represent [dynamic] as [null].
       return graph.addConstantNull(compiler);
     }
 
@@ skipping 386 matching lines @@
       push(new HInvokeClosure(closureSelector, inputs, backend.dynamicType));
     }
   }
 
   visitGetterSend(ast.Send node) {
     generateGetter(node, elements[node]);
   }
 
   // TODO(antonm): migrate rest of SsaFromAstMixin to internalError.
   internalError(String reason, {ast.Node node}) {
-    compiler.internalError(reason, node: node);
+    compiler.internalError(node, reason);
   }
 
   void generateError(ast.Node node, String message, Element helper) {
     HInstruction errorMessage = addConstantString(message);
     pushInvokeStatic(node, helper, [errorMessage]);
   }
 
   void generateRuntimeError(ast.Node node, String message) {
     generateError(node, message, backend.getThrowRuntimeError());
   }
@@ skipping 349 matching lines @@
       assert(!link.isEmpty && link.tail.isEmpty);
       if (Elements.isInstanceSend(node, elements)) {
         HInstruction receiver = generateInstanceSendReceiver(node);
         visit(link.head);
         generateInstanceSetterWithCompiledReceiver(node, receiver, pop());
       } else {
         visit(link.head);
         generateNonInstanceSetter(node, element, pop());
       }
     } else if (identical(op.source, "is")) {
-      compiler.internalError("is-operator as SendSet", node: op);
+      compiler.internalError(op, "is-operator as SendSet.");
     } else {
       assert("++" == op.source || "--" == op.source ||
              node.assignmentOperator.source.endsWith("="));
 
       // [receiver] is only used if the node is an instance send.
       HInstruction receiver = null;
       Element getter = elements[node.selector];
 
       if (!Elements.isUnresolved(getter) && getter.impliesType()) {
         ast.Identifier selector = node.selector;
@@ skipping 72 matching lines @@
       }
     }
   }
 
   void visitParenthesizedExpression(ast.ParenthesizedExpression node) {
     visit(node.expression);
   }
 
   visitOperator(ast.Operator node) {
     // Operators are intercepted in their surrounding Send nodes.
-    compiler.internalError('visitOperator should not be called', node: node);
+    compiler.internalError(node,
+        'SsaBuilder.visitOperator should not be called.');
   }
 
   visitCascade(ast.Cascade node) {
     visit(node.expression);
     // Remove the result and reveal the duplicated receiver on the stack.
     pop();
   }
 
   visitCascadeReceiver(ast.CascadeReceiver node) {
     visit(node.expression);
     dup();
   }
 
   void handleInTryStatement() {
     if (!inTryStatement) return;
     HBasicBlock block = close(new HExitTry());
     HBasicBlock newBlock = graph.addNewBlock();
     block.addSuccessor(newBlock);
     open(newBlock);
   }
 
   visitRethrow(ast.Rethrow node) {
     HInstruction exception = rethrowableException;
     if (exception == null) {
       exception = graph.addConstantNull(compiler);
-      compiler.internalError(
-          'rethrowableException should not be null', node: node);
+      compiler.internalError(node,
+          'rethrowableException should not be null.');
     }
     handleInTryStatement();
     closeAndGotoExit(new HThrow(exception, isRethrow: true));
   }
 
   visitReturn(ast.Return node) {
     if (identical(node.getBeginToken().stringValue, 'native')) {
       native.handleSsaNative(this, node.expression);
       return;
     }
@@ skipping 46 matching lines @@
   visitThrow(ast.Throw node) {
     visitThrowExpression(node.expression);
     if (isReachable) {
       handleInTryStatement();
       push(new HThrowExpression(pop()));
       isReachable = false;
     }
   }
 
   visitTypeAnnotation(ast.TypeAnnotation node) {
-    compiler.internalError('visiting type annotation in SSA builder',
-                           node: node);
+    compiler.internalError(node,
+        'Visiting type annotation in SSA builder.');
   }
 
   visitVariableDefinitions(ast.VariableDefinitions node) {
     assert(isReachable);
     for (Link<ast.Node> link = node.definitions.nodes;
          !link.isEmpty;
          link = link.tail) {
       ast.Node definition = link.head;
       if (definition is ast.Identifier) {
         HInstruction initialValue = graph.addConstantNull(compiler);
@@ skipping 52 matching lines @@
   }
 
   visitStringInterpolation(ast.StringInterpolation node) {
     StringBuilderVisitor stringBuilder = new StringBuilderVisitor(this, node);
     stringBuilder.visit(node);
     stack.add(stringBuilder.result);
   }
 
   visitStringInterpolationPart(ast.StringInterpolationPart node) {
     // The parts are iterated in visitStringInterpolation.
-    compiler.internalError('visitStringInterpolation should not be called',
-                           node: node);
+    compiler.internalError(node,
+      'SsaBuilder.visitStringInterpolation should not be called.');
   }
 
   visitEmptyStatement(ast.EmptyStatement node) {
     // Do nothing, empty statement.
   }
 
   visitModifiers(ast.Modifiers node) {
-    compiler.unimplemented('SsaFromAstMixin.visitModifiers', node: node);
+    compiler.unimplemented(node, 'SsaFromAstMixin.visitModifiers.');
   }
 
   visitBreakStatement(ast.BreakStatement node) {
     assert(!isAborted());
     handleInTryStatement();
     TargetElement target = elements[node];
     assert(target != null);
     JumpHandler handler = jumpTargets[target];
     assert(handler != null);
     if (node.target == null) {
@@ skipping 87 matching lines @@
         generateNonInstanceSetter(null, variable, value, location: identifier);
       }
       pop(); // Pop the value pushed by the setter call.
 
       visit(node.body);
     }
     handleLoop(node, buildInitializer, buildCondition, () {}, buildBody);
   }
 
   visitLabel(ast.Label node) {
-    compiler.internalError('SsaFromAstMixin.visitLabel', node: node);
+    compiler.internalError(node, 'SsaFromAstMixin.visitLabel.');
   }
 
   visitLabeledStatement(ast.LabeledStatement node) {
     ast.Statement body = node.statement;
     if (body is ast.Loop
         || body is ast.SwitchStatement
         || Elements.isUnusedLabel(node, elements)) {
       // Loops and switches handle their own labels.
       visit(body);
       return;
@@ skipping 409 matching lines @@
         new HSwitchBlockInformation(expressionInfo,
                                     statements,
                                     jumpHandler.target,
                                     jumpHandler.labels()),
         joinBlock);
 
     jumpHandler.close();
   }
 
   visitSwitchCase(ast.SwitchCase node) {
-    compiler.internalError('SsaFromAstMixin.visitSwitchCase');
+    compiler.internalError(node, 'SsaFromAstMixin.visitSwitchCase.');
   }
 
   visitCaseMatch(ast.CaseMatch node) {
-    compiler.internalError('SsaFromAstMixin.visitCaseMatch');
+    compiler.internalError(node, 'SsaFromAstMixin.visitCaseMatch.');
   }
 
   visitTryStatement(ast.TryStatement node) {
     // Save the current locals. The catch block and the finally block
     // must not reuse the existing locals handler. None of the variables
     // that have been defined in the body-block will be used, but for
     // loops we will add (unnecessary) phis that will reference the body
     // variables. This makes it look as if the variables were used
     // in a non-dominated block.
     LocalsHandler savedLocals = new LocalsHandler.from(localsHandler);
@@ skipping 36 matching lines @@
 
       pushInvokeStatic(node, backend.getExceptionUnwrapper(), [exception]);
       HInvokeStatic unwrappedException = pop();
       tryInstruction.exception = exception;
       Link<ast.Node> link = node.catchBlocks.nodes;
 
       void pushCondition(ast.CatchBlock catchBlock) {
         if (catchBlock.onKeyword != null) {
           DartType type = elements.getType(catchBlock.type);
           if (type == null) {
-            compiler.internalError('On with no type', node: catchBlock.type);
+            compiler.internalError(catchBlock.type, 'On with no type.');
           }
           HInstruction condition =
               buildIsNode(catchBlock.type, type, unwrappedException);
           push(condition);
         } else {
           ast.VariableDefinitions declaration = catchBlock.formals.nodes.head;
           HInstruction condition = null;
           if (declaration.type == null) {
             condition = graph.addConstantBool(true, compiler);
             stack.add(condition);
           } else {
             // TODO(aprelev@gmail.com): Once old catch syntax is removed
             // "if" condition above and this "else" branch should be deleted as
             // type of declared variable won't matter for the catch
             // condition.
             DartType type = elements.getType(declaration.type);
             if (type == null) {
-              compiler.cancel('Catch with unresolved type', node: catchBlock);
+              compiler.internalError(catchBlock, 'Catch with unresolved type.');
             }
             condition = buildIsNode(declaration.type, type, unwrappedException);
             push(condition);
           }
         }
       }
 
       void visitThen() {
         ast.CatchBlock catchBlock = link.head;
         link = link.tail;
@@ skipping 104 matching lines @@
           wrapStatementGraph(finallyGraph)),
         exitBlock);
     inTryStatement = oldInTryStatement;
   }
 
   visitCatchBlock(ast.CatchBlock node) {
     visit(node.block);
   }
 
   visitTypedef(ast.Typedef node) {
-    compiler.unimplemented('SsaFromAstMixin.visitTypedef', node: node);
+    compiler.unimplemented(node, 'SsaFromAstMixin.visitTypedef.');
   }
 
   visitTypeVariable(ast.TypeVariable node) {
-    compiler.internalError('SsaFromAstMixin.visitTypeVariable');
+    compiler.internalError(node, 'SsaFromAstMixin.visitTypeVariable.');
   }
 
   /**
    * This method is invoked before inlining the body of [function] into this
    * [SsaBuilder].
    */
   void enterInlinedMethod(FunctionElement function,
                           ast.Node _,
                           List<HInstruction> compiledArguments) {
     AstInliningState state = new AstInliningState(
@@ skipping 43 matching lines @@
    */
   HInstruction result = null;
 
   StringBuilderVisitor(this.builder, this.diagnosticNode);
 
   void visit(ast.Node node) {
     node.accept(this);
   }
 
   visitNode(ast.Node node) {
-    builder.compiler.internalError('unexpected node', node: node);
+    builder.compiler.internalError(node, 'Unexpected node.');
   }
 
   void visitExpression(ast.Node node) {
     node.accept(builder);
     HInstruction expression = builder.pop();
     if (!expression.isConstantString()) {
       expression = new HStringify(expression, node, builder.backend.stringType);
       builder.add(expression);
     }
     result = (result == null) ? expression : concat(result, expression);
@@ skipping 169 matching lines @@
 class SsaBranchBuilder {
   final SsaBuilder builder;
   final ast.Node diagnosticNode;
 
   SsaBranchBuilder(this.builder, [this.diagnosticNode]);
 
   Compiler get compiler => builder.compiler;
 
   void checkNotAborted() {
     if (builder.isAborted()) {
-      compiler.unimplemented("aborted control flow", node: diagnosticNode);
+      compiler.unimplemented(diagnosticNode, "aborted control flow");
     }
   }
 
   void buildCondition(void visitCondition(),
                       SsaBranch conditionBranch,
                       SsaBranch thenBranch,
                       SsaBranch elseBranch) {
     startBranch(conditionBranch);
     visitCondition();
     checkNotAborted();
@@ skipping 290 matching lines @@
     DartType unaliased = type.unalias(builder.compiler);
     if (unaliased is TypedefType) throw 'unable to unalias $type';
     unaliased.accept(this, builder);
   }
 
   void visitDynamicType(DynamicType type, SsaBuilder builder) {
     ClassElement cls = builder.compiler.findHelper('DynamicRuntimeType');
     builder.push(new HDynamicType(type, new TypeMask.exact(cls)));
   }
 }