Non-fatal errors in compile-time constants.

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 117 matching lines @@
    * error.
    */
   ConstantExpression compileVariableWithDefinitions(VariableElement element,
                                                     TreeElements definitions,
                                                     {bool isConst: false}) {
     Node node = element.node;
     if (pendingVariables.contains(element)) {
       if (isConst) {
         compiler.reportError(
             node, MessageKind.CYCLIC_COMPILE_TIME_CONSTANTS);
-        // TODO(ahe): Don't throw, recover from error.
-        throw new CompilerCancelledException(null);
+        return new ErroneousConstantExpression();
       }
       return null;
     }
     pendingVariables.add(element);
 
     Expression initializer = element.initializer;
     ConstantExpression value;
     if (initializer == null) {
       // No initial value.
       value = new PrimitiveConstantExpression(new NullConstantValue());
@@ skipping 463 matching lines @@
   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.reportError(
             node.condition, MessageKind.NOT_ASSIGNABLE,
             {'fromType': conditionType, 'toType': compiler.boolClass.rawType});
-        // TODO(ahe): Don't throw, recover from error.
-        throw new CompilerCancelledException(null);
+        return new ErroneousAstConstant(context, node);
       }
       return null;
     }
     AstConstant thenExpression = evaluate(node.thenExpression);
     AstConstant elseExpression = evaluate(node.elseExpression);
     if (thenExpression == null || elseExpression == null) {
       return null;
     }
     BoolConstantValue boolCondition = condition.value;
     return new AstConstant(
@@ skipping 31 matching lines @@
     }
     target.computeSignature(compiler);
 
     if (!selector.applies(target, compiler.world)) {
       String name = Elements.constructorNameForDiagnostics(
           target.enclosingClass.name, target.name);
       compiler.reportError(
           node,
           MessageKind.INVALID_CONSTRUCTOR_ARGUMENTS,
           {'constructorName': name});
-      // TODO(ahe): Don't throw, recover from error.
-      throw new CompilerCancelledException(null);
+
+      return new List<AstConstant>.filled(
+          target.functionSignature.parameterCount,
+          new ErroneousAstConstant(context, node));
     }
     return selector.makeArgumentsList2(arguments,
                                        target,
                                        compileArgument,
                                        compileDefaultValue);
   }
 
   AstConstant visitNewExpression(NewExpression node) {
     if (!node.isConst) {
       return signalNotCompileTimeConstant(node);
@@ skipping 131 matching lines @@
   static AstConstant makeConstructedConstant(
       Compiler compiler,
       ConstantCompilerBase handler,
       Element context,
       Node node,
       InterfaceType type,
       ConstructorElement constructor,
       Selector selector,
       List<AstConstant> concreteArguments,
       List<AstConstant> normalizedArguments) {
-    assert(invariant(node, selector.applies(constructor, compiler.world),
+    assert(invariant(node, selector.applies(constructor, compiler.world) ||
+                     compiler.compilationFailed,
         message: "Selector $selector does not apply to constructor "
                  "$constructor."));
 
     // The redirection chain of this element may not have been resolved through
     // a post-process action, so we have to make sure it is done here.
     compiler.resolver.resolveRedirectionChain(constructor, node);
     InterfaceType constructedType =
         constructor.computeEffectiveTargetType(type);
     ConstructorElement target = constructor.effectiveTarget;
     ClassElement classElement = target.enclosingClass;
@@ skipping 270 matching lines @@
       ConstantExpression constant) {
     return new AstConstant(
         element,
         element.initializer != null ? element.initializer : element.node,
         constant);
   }
 
   ConstantValue get value => expression.value;
 
   String toString() => expression.toString();
-}
+}
+
+/// A synthetic constant used to recover from errors.
+class ErroneousAstConstant extends AstConstant {
+  ErroneousAstConstant(Element element, Node node)
+      : super(element, node, new ErroneousConstantExpression());
+}