Clean up error handling.

dart/sdk/lib/_internal/compiler/implementation/compile_time_constants.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 dart2js;
 
 /**
  * The [ConstantHandler] keeps track of compile-time constants,
  * initializations of global and static fields, and default values of
  * optional parameters.
@@ skipping 158 matching lines @@
                                           {bool isConst: false}) {
     return measure(() {
       // Initializers for parameters must be const.
       isConst = isConst || element.modifiers.isConst()
           || !Elements.isStaticOrTopLevel(element);
       if (!isConst && lazyStatics.contains(element)) return null;
 
       Node node = element.parseNode(compiler);
       if (pendingVariables.contains(element)) {
         if (isConst) {
-          MessageKind kind = MessageKind.CYCLIC_COMPILE_TIME_CONSTANTS;
-          compiler.reportError(node,
-                               new CompileTimeConstantError(kind));
+          compiler.reportFatalError(
+              node, MessageKind.CYCLIC_COMPILE_TIME_CONSTANTS);
         } else {
           lazyStatics.add(element);
           return null;
         }
       }
       pendingVariables.add(element);
 
       SendSet assignment = node.asSendSet();
       Constant value;
       if (assignment == null) {
         // No initial value.
         value = new NullConstant();
       } else {
         Node right = assignment.arguments.head;
         value =
             compileNodeWithDefinitions(right, definitions, isConst: isConst);
         if (compiler.enableTypeAssertions
             && value != null
             && element.isField()) {
           DartType elementType = element.computeType(compiler);
           DartType constantType = value.computeType(compiler);
           if (elementType.isMalformed || constantType.isMalformed ||
               !constantSystem.isSubtype(compiler, constantType, elementType)) {
             if (isConst) {
-              compiler.reportError(node, new CompileTimeConstantError(
-                  MessageKind.NOT_ASSIGNABLE,
-                  {'fromType': constantType, 'toType': elementType}));
+              compiler.reportFatalError(
+                  node, MessageKind.NOT_ASSIGNABLE.error,
+                  {'fromType': constantType, 'toType': elementType});
             } else {
               // If the field can be lazily initialized, we will throw
               // the exception at runtime.
               value = null;
             }
           }
         }
       }
       if (value != null) {
         initialVariableValues[element] = value;
@@ skipping 170 matching lines @@
       return signalNotCompileTimeConstant(node);
     }
     List<StringConstant> keys = <StringConstant>[];
     Map<StringConstant, Constant> map = new Map<StringConstant, Constant>();
     for (Link<Node> link = node.entries.nodes;
          !link.isEmpty;
          link = link.tail) {
       LiteralMapEntry entry = link.head;
       Constant key = evaluateConstant(entry.key);
       if (!key.isString() || entry.key.asStringNode() == null) {
-        MessageKind kind = MessageKind.KEY_NOT_A_STRING_LITERAL;
-        compiler.reportError(entry.key, new ResolutionError(kind));
+        compiler.reportFatalError(
+            entry.key, MessageKind.KEY_NOT_A_STRING_LITERAL);
       }
       StringConstant keyConstant = key;
       if (!map.containsKey(key)) keys.add(key);
       map[key] = evaluateConstant(entry.value);
     }
     List<Constant> values = <Constant>[];
     Constant protoValue = null;
     for (StringConstant key in keys) {
       if (key.value == MapConstant.PROTO_PROPERTY) {
         protoValue = map[key];
@@ skipping 251 matching lines @@
 
     Function compileArgument = evaluateConstant;
     Function compileConstant = handler.compileConstant;
     bool succeeded = selector.addArgumentsToList(arguments,
                                                  compiledArguments,
                                                  target,
                                                  compileArgument,
                                                  compileConstant,
                                                  compiler);
     if (!succeeded) {
-      MessageKind kind = MessageKind.INVALID_ARGUMENTS;
-      compiler.reportError(node,
-          new CompileTimeConstantError(kind, {'methodName': target.name}));
+      compiler.reportFatalError(
+          node,
+          MessageKind.INVALID_ARGUMENTS.error, {'methodName': target.name});
     }
     return compiledArguments;
   }
 
   Constant visitNewExpression(NewExpression node) {
     if (!node.isConst()) {
       return signalNotCompileTimeConstant(node);
     }
 
     Send send = node.send;
@@ skipping 29 matching lines @@
     return constant;
   }
 
   Constant visitParenthesizedExpression(ParenthesizedExpression node) {
     return node.expression.accept(this);
   }
 
   error(Node node) {
     // TODO(floitsch): get the list of constants that are currently compiled
     // and present some kind of stack-trace.
-    MessageKind kind = MessageKind.NOT_A_COMPILE_TIME_CONSTANT;
-    compiler.reportError(node, new CompileTimeConstantError(kind));
+    compiler.reportFatalError(
+        node, MessageKind.NOT_A_COMPILE_TIME_CONSTANT);
   }
 
   Constant signalNotCompileTimeConstant(Node node) {
     if (isEvaluatingConstant) {
       error(node);
     }
     // Else we don't need to do anything. The final handler is only
     // optimistically trying to compile constants. So it is normal that we
     // sometimes see non-compile time constants.
     // Simply return [:null:] which is used to propagate a failing
     // compile-time compilation.
     return null;
   }
 }
 
 class TryCompileTimeConstantEvaluator extends CompileTimeConstantEvaluator {
   TryCompileTimeConstantEvaluator(ConstantHandler handler,
                                   TreeElements elements,
                                   Compiler compiler)
       : super(handler, elements, compiler, isConst: true);
 
   error(Node node) {
     // Just fail without reporting it anywhere.
-    throw new CompileTimeConstantError(
-        MessageKind.NOT_A_COMPILE_TIME_CONSTANT);
+    throw new CompileTimeConstantError(MessageKind.NOT_A_COMPILE_TIME_CONSTANT);
   }
 }
 
 class ConstructorEvaluator extends CompileTimeConstantEvaluator {
   final FunctionElement constructor;
   final Map<Element, Constant> definitions;
   final Map<Element, Constant> fieldValues;
 
   /**
    * Documentation wanted -- johnniwinther
@@ skipping 26 matching lines @@
   }
 
   void potentiallyCheckType(Node node, Element element, Constant constant) {
     if (compiler.enableTypeAssertions) {
       DartType elementType = element.computeType(compiler);
       DartType constantType = constant.computeType(compiler);
       // TODO(ngeoffray): Handle type parameters.
       if (elementType.element.isTypeVariable()) return;
       if (elementType.isMalformed || constantType.isMalformed ||
           !constantSystem.isSubtype(compiler, constantType, elementType)) {
-        compiler.reportError(node, new CompileTimeConstantError(
-            MessageKind.NOT_ASSIGNABLE,
-            {'fromType': elementType, 'toType': constantType}));
+        compiler.reportFatalError(
+            node, MessageKind.NOT_ASSIGNABLE.error,
+            {'fromType': elementType, 'toType': constantType});
       }
     }
   }
 
   void updateFieldValue(Node node, Element element, Constant constant) {
     potentiallyCheckType(node, element, constant);
     fieldValues[element] = constant;
   }
 
   /**
@@ skipping 122 matching lines @@
           if (fieldValue == null) {
             // Use the default value.
             fieldValue = handler.compileConstant(field);
           }
           jsNewArguments.add(fieldValue);
         },
         includeSuperAndInjectedMembers: true);
     return jsNewArguments;
   }
 }