Clean up error handling.

dart/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 override [Element.computeType] because our
  * optimizers may look at its declared type.
@@ skipping 3010 matching lines @@
       }
       pushInvokeStatic(null, element, [], HType.UNKNOWN);
     }
   }
 
   void handleForeignJsGetName(Send node) {
     List<Node> arguments = node.arguments.toList();
     Node argument;
     switch (arguments.length) {
     case 0:
-      compiler.reportErrorCode(
+      compiler.reportError(
           node, MessageKind.GENERIC,
           {'text': 'Error: Expected one argument to JS_GET_NAME.'});
       return;
     case 1:
       argument = arguments[0];
       break;
     default:
       for (int i = 1; i < arguments.length; i++) {
-        compiler.reportErrorCode(
+        compiler.reportError(
             arguments[i], MessageKind.GENERIC,
             {'text': 'Error: Extra argument to JS_GET_NAME.'});
       }
       return;
     }
     LiteralString string = argument.asLiteralString();
     if (string == null) {
-      compiler.reportErrorCode(
+      compiler.reportError(
           argument, MessageKind.GENERIC,
           {'text': 'Error: Expected a literal string.'});
     }
     stack.add(
         addConstantString(
             argument,
             backend.namer.getNameForJsGetName(
                 argument, string.dartString.slowToString())));
   }
 
@@ skipping 702 matching lines @@
 
   visitNewExpression(NewExpression node) {
     Element element = elements[node.send];
     final bool isSymbolConstructor = element == compiler.symbolConstructor;
     if (!Elements.isErroneousElement(element)) {
       FunctionElement function = element;
       element = function.redirectionTarget;
     }
     if (Elements.isErroneousElement(element)) {
       ErroneousElement error = element;
-      if (error.messageKind == MessageKind.CANNOT_FIND_CONSTRUCTOR) {
+      if (error.messageKind == MessageKind.CANNOT_FIND_CONSTRUCTOR.error) {
         generateThrowNoSuchMethod(node.send,
                                   getTargetName(error, 'constructor'),
                                   argumentNodes: node.send.arguments);
       } else {
         Message message = error.messageKind.message(error.messageArguments);
         generateRuntimeError(node.send, message.toString());
       }
     } else if (node.isConst()) {
       ConstantHandler handler = compiler.constantHandler;
       Constant constant = handler.compileNodeWithDefinitions(node, elements);
@@ skipping 678 matching lines @@
     for (SwitchCase switchCase in node.cases) {
       for (Node labelOrCase in switchCase.labelsAndCases) {
         if (labelOrCase is CaseMatch) {
           CaseMatch match = labelOrCase;
           Constant constant =
               compiler.constantHandler.compileNodeWithDefinitions(
                   match.expression, elements, isConst: true);
           if (firstConstantType == null) {
             firstConstantType = constant.computeType(compiler);
             if (nonPrimitiveTypeOverridesEquals(constant)) {
-              compiler.reportError(match.expression,
-                  MessageKind.SWITCH_CASE_VALUE_OVERRIDES_EQUALS.error());
+              compiler.reportFatalError(
+                  match.expression,
+                  MessageKind.SWITCH_CASE_VALUE_OVERRIDES_EQUALS);
               failure = true;
             }
           } else {
             DartType constantType =
                 constant.computeType(compiler);
             if (constantType != firstConstantType) {
-              compiler.reportError(match.expression,
-                  MessageKind.SWITCH_CASE_TYPES_NOT_EQUAL.error());
+              compiler.reportFatalError(
+                  match.expression,
+                  MessageKind.SWITCH_CASE_TYPES_NOT_EQUAL);
               failure = true;
             }
           }
           constants[labelOrCase] = constant;
         }
       }
     }
     return constants;
   }
 
@@ skipping 1026 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;
   }
 }