Recover from crash in xcodebuild/ReleaseIA32/generated_tests/language/async_test_constructor4.dart.

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 936 matching lines @@
     potentiallyCheckType(node, element, constant);
     fieldValues[element] = constant;
   }
 
   /**
    * Given the arguments (a list of constants) assigns them to the parameters,
    * updating the definitions map. If the constructor has field-initializer
    * parameters (like [:this.x:]), also updates the [fieldValues] map.
    */
   void assignArgumentsToParameters(List<AstConstant> arguments) {
+    if (constructor.isErroneous) return;

[Johnni Winther, 2015/01/15 09:31:48]

Shouldn't we generate an ErroneousConstantExpression for the constructed object
instead?

[ahe, 2015/01/15 12:07:21]

I'll look at that in a follow up.

     // Assign arguments to parameters.
     FunctionSignature signature = constructor.functionSignature;
     int index = 0;
     signature.orderedForEachParameter((ParameterElement parameter) {
       AstConstant argument = arguments[index++];
       Node node = parameter.node;
       if (parameter.isInitializingFormal) {
         InitializingFormalElement initializingFormal = parameter;
         updateFieldValue(node, initializingFormal.fieldElement, argument);
       } else {
@@ skipping 91 matching lines @@
       }
     }
   }
 
   /**
    * Simulates the execution of the [constructor] with the given
    * [arguments] to obtain the field values that need to be passed to the
    * native JavaScript constructor.
    */
   void evaluateConstructorFieldValues(List<AstConstant> arguments) {
+    if (constructor.isErroneous) return;
     compiler.withCurrentElement(constructor, () {
       assignArgumentsToParameters(arguments);
       evaluateConstructorInitializers();
     });
   }
 
   /// Builds a normalized list of the constant values for each field in the
   /// inheritance chain of [classElement].
   List<AstConstant> buildFieldConstants(ClassElement classElement) {
     List<AstConstant> fieldConstants = <AstConstant>[];
@@ skipping 40 matching lines @@
   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());
 }