Introduce .isMalformed

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.
 
 library dart2js.compile_time_constant_evaluator;
 
 import 'common.dart';
 import 'common/resolution.dart' show
     Resolution;
 import 'common/tasks.dart' show
@@ skipping 812 matching lines @@
     // 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;
     // The constructor must be an implementation to ensure that field
     // initializers are handled correctly.
     ConstructorElement implementation = target.implementation;
 
-    if (implementation.isErroneous) {
+    if (implementation.isMalformed) {
       // TODO(johnniwinther): This should probably be an [ErroneousAstConstant].
       return new AstConstant(context, node, new ConstructedConstantExpression(
               type, constructor, callStructure, const <ConstantExpression>[]),
           new ConstructedConstantValue(
               constructedType, const <FieldElement, ConstantValue>{}));
     }
 
     List<AstConstant> concreteArguments;
     if (arguments != null) {
       Map<Node, AstConstant> concreteArgumentMap = <Node, AstConstant>{};
@@ skipping 238 matching lines @@
     potentiallyCheckType(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;
+    if (constructor.isMalformed) return;
     // 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 83 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;
+    if (constructor.isMalformed) return;
     reporter.withCurrentElement(constructor, () {
       assignArgumentsToParameters(arguments);
       evaluateConstructorInitializers();
     });
   }
 
   /// Builds a normalized list of the constant values for each field in the
   /// inheritance chain of [classElement].
   Map<FieldElement, AstConstant> buildFieldConstants(
       ClassElement classElement) {
@@ skipping 62 matching lines @@
 class _CompilerEnvironment implements Environment {
   final Compiler compiler;
 
   _CompilerEnvironment(this.compiler);
 
   @override
   String readFromEnvironment(String name) {
     return compiler.fromEnvironment(name);
   }
 }