Introduce .isMalformed

pkg/compiler/lib/src/elements/elements.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 elements;
 
 import '../common.dart';
 import '../common/resolution.dart' show
     Resolution;
 import '../compiler.dart' show
@@ skipping 68 matching lines @@
   static const ElementKind INITIALIZING_FORMAL =
       const ElementKind('initializing_formal', ElementCategory.VARIABLE);
   static const ElementKind FUNCTION =
       const ElementKind('function', ElementCategory.FUNCTION);
   static const ElementKind CLASS =
       const ElementKind('class', ElementCategory.CLASS);
   static const ElementKind GENERATIVE_CONSTRUCTOR =
       const ElementKind('generative_constructor', ElementCategory.FACTORY);
   static const ElementKind FIELD =
       const ElementKind('field', ElementCategory.VARIABLE);
-  static const ElementKind FIELD_LIST =
-      const ElementKind('field_list', ElementCategory.NONE);

[Johnni Winther, 2015/10/21 07:51:56]

Nice!

[sigurdm, 2015/10/22 07:33:14]

Acknowledged.

   static const ElementKind GENERATIVE_CONSTRUCTOR_BODY =
       const ElementKind('generative_constructor_body', ElementCategory.NONE);
   static const ElementKind COMPILATION_UNIT =
       const ElementKind('compilation_unit', ElementCategory.NONE);
   static const ElementKind GETTER =
       const ElementKind('getter', ElementCategory.NONE);
   static const ElementKind SETTER =
       const ElementKind('setter', ElementCategory.NONE);
   static const ElementKind TYPE_VARIABLE =
       const ElementKind('type_variable', ElementCategory.TYPE_VARIABLE);
@@ skipping 164 matching lines @@
   ///
   /// This property is `false` if this element is an initializing formal.
   /// See [isInitializingFormal].
   bool get isParameter;
 
   /// `true` if this element is an initializing formal of constructor, that
   /// is a formal of the form `this.foo`.
   bool get isInitializingFormal;
 
   /// `true` if this element represents a resolution error.
-  bool get isErroneous;
+  bool get isError;
 
   /// `true` if this element represents an ambiguous name.
   ///
   /// Ambiguous names occur when two imports/exports contain different entities
   /// by the same name. If an ambiguous name is resolved an warning or error
   /// is produced.
   bool get isAmbiguous;
 
+  /// True if there has been errors during resolution or parsing of this
+  /// element.
+  bool get isMalformed;
+
   /// `true` if this element represents an entity whose access causes one or
   /// more warnings.
   bool get isWarnOnUse;
 
   bool get isClosure;
 
   /// `true` if the element is a (static or instance) member of a class.
   ///
   /// Members are constructors, methods and fields.
   bool get isClassMember;
@@ skipping 121 matching lines @@
   AnalyzableElement get analyzableElement;
 
   accept(ElementVisitor visitor, arg);
 
   void setJsInteropName(String name);
   void markAsJsInterop();
 }
 
 class Elements {
   static bool isUnresolved(Element e) {
-    return e == null || e.isErroneous;
+    return e == null || e.isMalformed;
   }
-  static bool isErroneous(Element e) => e != null && e.isErroneous;
+
+  static bool isMalformed(Element e) {
+    return e != null && e.isMalformed;
+  }
 
   /// Unwraps [element] reporting any warnings attached to it, if any.
   static Element unwrap(Element element,
                         DiagnosticReporter listener,
                         Spannable spannable) {
     if (element != null && element.isWarnOnUse) {
       WarnOnUseElement wrappedElement = element;
       element = wrappedElement.unwrap(listener, spannable);
     }
     return element;
@@ skipping 341 matching lines @@
   }
 }
 
 /// An element representing an erroneous resolution.
 ///
 /// An [ErroneousElement] is used instead of `null` to provide additional
 /// information about the error that caused the element to be unresolvable
 /// or otherwise invalid.
 ///
 /// Accessing any field or calling any method defined on [ErroneousElement]
-/// except [isErroneous] will currently throw an exception. (This might
+/// except [isError] will currently throw an exception. (This might
 /// change when we actually want more information on the erroneous element,
 /// e.g., the name of the element we were trying to resolve.)
 ///
 /// Code that cannot not handle an [ErroneousElement] should use
 /// `Element.isUnresolved(element)` to check for unresolvable elements instead
 /// of `element == null`.
 abstract class ErroneousElement extends Element implements ConstructorElement {
   MessageKind get messageKind;
   Map get messageArguments;
   String get message;
@@ skipping 910 matching lines @@
   bool get isDeclaredByField;
 
   /// Returns `true` if this member is abstract.
   bool get isAbstract;
 
   /// If abstract, [implementation] points to the overridden concrete member,
   /// if any. Otherwise [implementation] points to the member itself.
   Member get implementation;
 }