Remove Compiler.reportFatalError.

dart/pkg/compiler/lib/src/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;
 
 /// A [ConstantEnvironment] provides access for constants compiled for variable
 /// initializers.
 abstract class ConstantEnvironment {
   /// Returns the constant for the initializer of [element].
@@ skipping 115 matching lines @@
    * eagerly. If the variable needs to be initialized lazily returns `null`.
    * If the variable is `const` but cannot be compiled eagerly reports an
    * error.
    */
   ConstantExpression compileVariableWithDefinitions(VariableElement element,
                                                     TreeElements definitions,
                                                     {bool isConst: false}) {
     Node node = element.node;
     if (pendingVariables.contains(element)) {
       if (isConst) {
-        compiler.reportFatalError(
+        compiler.reportError(
             node, MessageKind.CYCLIC_COMPILE_TIME_CONSTANTS);
+        // TODO(ahe): Don't throw, recover from error.
+        throw new CompilerCancelledException(null);
       }
       return null;
     }
     pendingVariables.add(element);
 
     Expression initializer = element.initializer;
     ConstantExpression value;
     if (initializer == null) {
       // No initial value.
       value = new PrimitiveConstantExpression(new NullConstantValue());
     } else {
       value = compileNodeWithDefinitions(
           initializer, definitions, isConst: isConst);
       if (compiler.enableTypeAssertions &&
           value != null &&
           element.isField) {
         DartType elementType = element.type;
         if (elementType.isMalformed && !value.value.isNull) {
           if (isConst) {
             ErroneousElement element = elementType.element;
-            compiler.reportFatalError(
+            compiler.reportError(
                 node, element.messageKind, element.messageArguments);
           } else {
             // We need to throw an exception at runtime.
             value = null;
           }
         } else {
           DartType constantType = value.value.getType(compiler.coreTypes);
           if (!constantSystem.isSubtype(compiler.types,
                                         constantType, elementType)) {
             if (isConst) {
-              compiler.reportFatalError(
+              compiler.reportError(
                   node, MessageKind.NOT_ASSIGNABLE,
                   {'fromType': constantType, 'toType': elementType});
             } else {
               // If the field cannot be lazily initialized, we will throw
               // the exception at runtime.
               value = null;
             }
           }
         }
       }
@@ skipping 418 matching lines @@
     return signalNotCompileTimeConstant(send);
   }
 
   AstConstant visitConditional(Conditional node) {
     AstConstant condition = evaluate(node.condition);
     if (condition == null) {
       return null;
     } else if (!condition.value.isBool) {
       DartType conditionType = condition.value.getType(compiler.coreTypes);
       if (isEvaluatingConstant) {
-        compiler.reportFatalError(
+        compiler.reportError(
             node.condition, MessageKind.NOT_ASSIGNABLE,
             {'fromType': conditionType, 'toType': compiler.boolClass.rawType});
       }
       return null;
     }
     AstConstant thenExpression = evaluate(node.thenExpression);
     AstConstant elseExpression = evaluate(node.elseExpression);
     if (thenExpression == null || elseExpression == null) {
       return null;
     }
@@ skipping 29 matching lines @@
 
     AstConstant compileDefaultValue(VariableElement element) {
       ConstantExpression constant = handler.compileConstant(element);
       return new AstConstant.fromDefaultValue(element, constant);
     }
     target.computeSignature(compiler);
 
     if (!selector.applies(target, compiler.world)) {
       String name = Elements.constructorNameForDiagnostics(
           target.enclosingClass.name, target.name);
-      compiler.reportFatalError(
+      compiler.reportError(
           node,
           MessageKind.INVALID_CONSTRUCTOR_ARGUMENTS,
           {'constructorName': name});
+      // TODO(ahe): Don't throw, recover from error.
+      throw new CompilerCancelledException(null);
     }
     return selector.makeArgumentsList2(arguments,
                                        target,
                                        compileArgument,
                                        compileDefaultValue);
   }
 
   AstConstant visitNewExpression(NewExpression node) {
     if (!node.isConst) {
       return signalNotCompileTimeConstant(node);
@@ skipping 49 matching lines @@
                 type,
                 constructor,
                 elements.getSelector(send),
                 concreteArguments.map((e) => e.expression).toList()));
       }
 
       var firstArgument = normalizedArguments[0].value;
       ConstantValue defaultValue = normalizedArguments[1].value;
 
       if (firstArgument.isNull) {
-        compiler.reportFatalError(
+        compiler.reportError(
             send.arguments.head, MessageKind.NULL_NOT_ALLOWED);
         return null;
       }
 
       if (!firstArgument.isString) {
         DartType type = defaultValue.getType(compiler.coreTypes);
-        compiler.reportFatalError(
+        compiler.reportError(
             send.arguments.head, MessageKind.NOT_ASSIGNABLE,
             {'fromType': type, 'toType': compiler.stringClass.rawType});
         return null;
       }
 
       if (constructor == compiler.intEnvironment &&
           !(defaultValue.isNull || defaultValue.isInt)) {
         DartType type = defaultValue.getType(compiler.coreTypes);
-        compiler.reportFatalError(
+        compiler.reportError(
             send.arguments.tail.head, MessageKind.NOT_ASSIGNABLE,
             {'fromType': type, 'toType': compiler.intClass.rawType});
         return null;
       }
 
       if (constructor == compiler.boolEnvironment &&
           !(defaultValue.isNull || defaultValue.isBool)) {
         DartType type = defaultValue.getType(compiler.coreTypes);
-        compiler.reportFatalError(
+        compiler.reportError(
             send.arguments.tail.head, MessageKind.NOT_ASSIGNABLE,
             {'fromType': type, 'toType': compiler.boolClass.rawType});
         return null;
       }
 
       if (constructor == compiler.stringEnvironment &&
           !(defaultValue.isNull || defaultValue.isString)) {
         DartType type = defaultValue.getType(compiler.coreTypes);
-        compiler.reportFatalError(
+        compiler.reportError(
             send.arguments.tail.head, MessageKind.NOT_ASSIGNABLE,
             {'fromType': type, 'toType': compiler.stringClass.rawType});
         return null;
       }
 
       String value =
           compiler.fromEnvironment(firstArgument.primitiveValue.slowToString());
 
       if (value == null) {
         return createEvaluatedConstant(defaultValue);
@@ skipping 67 matching lines @@
             concreteArguments.map((e) => e.expression).toList()));
   }
 
   AstConstant visitParenthesizedExpression(ParenthesizedExpression node) {
     return node.expression.accept(this);
   }
 
   error(Node node, MessageKind message) {
     // TODO(floitsch): get the list of constants that are currently compiled
     // and present some kind of stack-trace.
-    compiler.reportFatalError(node, message);
+    compiler.reportError(node, message);
   }
 
   AstConstant signalNotCompileTimeConstant(Node node,
       {MessageKind message: MessageKind.NOT_A_COMPILE_TIME_CONSTANT}) {
     if (isEvaluatingConstant) {
       error(node, message);
+
+      return new AstConstant(
+          null, node, new PrimitiveConstantExpression(new NullConstantValue()));
     }
     // 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;
   }
 }
 
@@ skipping 36 matching lines @@
 
   void potentiallyCheckType(Node node,
                             TypedElement element,
                             AstConstant constant) {
     if (compiler.enableTypeAssertions) {
       DartType elementType = element.type.substByContext(constructedType);
       DartType constantType = constant.value.getType(compiler.coreTypes);
       if (!constantSystem.isSubtype(compiler.types,
                                     constantType, elementType)) {
         compiler.withCurrentElement(constant.element, () {
-          compiler.reportFatalError(
+          compiler.reportError(
               constant.node, MessageKind.NOT_ASSIGNABLE,
               {'fromType': constantType, 'toType': elementType});
         });
       }
     }
   }
 
   void updateFieldValue(Node node,
                         TypedElement element,
                         AstConstant constant) {
@@ skipping 165 matching lines @@
     return new AstConstant(
         element,
         element.initializer != null ? element.initializer : element.node,
         constant);
   }
 
   ConstantValue get value => expression.value;
 
   String toString() => expression.toString();
 }