Introduce .isMalformed

pkg/compiler/lib/src/elements/modelx.dart

 // Copyright (c) 2013, 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 elements.modelx;
 
 import '../common.dart';
 import '../common/resolution.dart' show
     Resolution,
     Parsing;
@@ skipping 40 matching lines @@
 abstract class ElementX extends Element with ElementCommon {
   static int elementHashCode = 0;
 
   final String name;
   final ElementKind kind;
   final Element enclosingElement;
   final int hashCode = ++elementHashCode;
   List<MetadataAnnotation> metadataInternal;
 
   ElementX(this.name, this.kind, this.enclosingElement) {
-    assert(isErroneous || implementationLibrary != null);
+    assert(isError || implementationLibrary != null);
   }
 
   Modifiers get modifiers => Modifiers.EMPTY;
 
   Node parseNode(Parsing parsing) {
     parsing.reporter.internalError(this,
         'parseNode not implemented on $this.');
     return null;
   }
 
@@ skipping 244 matching lines @@
   ErroneousElementX(this.messageKind, this.messageArguments,
                     String name, Element enclosing)
       : super(name, ElementKind.ERROR, enclosing);
 
   bool get isTopLevel => false;
 
   bool get isSynthesized => true;
 
   bool get isCyclicRedirection => false;
 
+  bool get isMalformed => true;
+
   PrefixElement get redirectionDeferredPrefix => null;
 
   AbstractFieldElement abstractField;
 
   unsupported() {
     throw 'unsupported operation on erroneous element';
   }
 
   get asyncMarker => AsyncMarker.SYNC;
   Iterable<MetadataAnnotation> get metadata => unsupported();
@@ skipping 293 matching lines @@
 
 /// Element synthesized to recover from a duplicated member of an element.
 class DuplicatedElementX extends AmbiguousElementX {
   DuplicatedElementX(
       MessageKind messageKind,
       Map messageArguments,
       Element enclosingElement, Element existingElement, Element newElement)
       : super(messageKind, messageArguments, enclosingElement, existingElement,
               newElement);
 
-  bool get isErroneous => true;
+  bool get isMalformed => true;
 }
 
 class ScopeX {
   final Map<String, Element> contents = new Map<String, Element>();
 
   bool get isEmpty => contents.isEmpty;
   Iterable<Element> get values => contents.values;
 
   Element lookup(String name) {
     return contents[name];
@@ skipping 1050 matching lines @@
   set initializerCache(_) {
     throw new UnsupportedError("initializerCache=");
   }
 
   void createDefinitions(VariableDefinitions definitions) {
     throw new UnsupportedError("createDefinitions");
   }
 
   get initializer => null;
 
-  bool get isErroneous => true;
+  bool get isMalformed => true;
 
   get nestedClosures {
     throw new UnsupportedError("nestedClosures");
   }
 
   set nestedClosures(_) {
     throw new UnsupportedError("nestedClosures=");
   }
 
   // TODO(ahe): Should this throw or do nothing?
@@ skipping 185 matching lines @@
         super(
             ElementKind.INITIALIZING_FORMAL,
             enclosingElement, null, identifier, null);
 
   VariableDefinitions get definitions => fieldElement.node;
 
   MemberElement get memberContext => enclosingElement;
 
   bool get isLocal => false;
 
-  bool get isErroneous => true;
+  bool get isMalformed => true;
 
   DynamicType get type => const DynamicType();
 }
 
 class AbstractFieldElementX extends ElementX implements AbstractFieldElement {
   GetterElementX getter;
   SetterElementX setter;
 
   AbstractFieldElementX(String name, Element enclosing)
       : super(name, ElementKind.ABSTRACT_FIELD, enclosing);
@@ skipping 346 matching lines @@
   /// This field is set by the post process queue when checking for cycles.
   ConstructorElement internalEffectiveTarget;
   DartType effectiveTargetType;
 
   void set effectiveTarget(ConstructorElement constructor) {
     assert(constructor != null && internalEffectiveTarget == null);
     internalEffectiveTarget = constructor;
   }
 
   ConstructorElement get effectiveTarget {
-    if (Elements.isErroneous(immediateRedirectionTarget)) {
+    if (Elements.isMalformed(immediateRedirectionTarget)) {
       return immediateRedirectionTarget;
     }
     assert(!isRedirectingFactory || internalEffectiveTarget != null);
     if (isRedirectingFactory) return internalEffectiveTarget;
     if (isPatched) {
       return internalEffectiveTarget ?? this;
     }
     return this;
   }
 
@@ skipping 134 matching lines @@
       return super.type;
     } else {
       // TODO(johnniwinther): Ensure that the function type substitutes type
       // variables correctly.
       return definingConstructor.type;
     }
   }
 
   void _computeSignature(Resolution resolution) {
     if (hasFunctionSignature) return;
-    if (definingConstructor.isErroneous) {
+    if (definingConstructor.isMalformed) {
       functionSignature = new FunctionSignatureX(
           type: new FunctionType.synthesized(enclosingClass.thisType));
     }
     // TODO(johnniwinther): Ensure that the function signature (and with it the
     // function type) substitutes type variables correctly.
     definingConstructor.computeType(resolution);
     functionSignature = definingConstructor.functionSignature;
   }
 
   accept(ElementVisitor visitor, arg) {
@@ skipping 734 matching lines @@
   AstElement get definingElement;
 
   bool get hasResolvedAst => definingElement.hasTreeElements;
 
   ResolvedAst get resolvedAst {
     return new ResolvedAst(declaration,
         definingElement.node, definingElement.treeElements);
   }
 
 }