A bit of element model cleanup.

sdk/lib/_internal/compiler/implementation/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 'elements.dart';
 import '../helpers/helpers.dart';
 import '../tree/tree.dart';
 import '../util/util.dart';
@@ skipping 72 matching lines @@
   bool get isDeferredLoaderGetter => false;
 
   bool get isFactoryConstructor => modifiers.isFactory;
   bool get isConst => modifiers.isConst;
   bool get isFinal => modifiers.isFinal;
   bool get isStatic => modifiers.isStatic;
   bool get isOperator => Elements.isOperatorName(name);
   bool get isStatement => identical(kind, ElementKind.STATEMENT);
   bool get impliesType => (kind.category & ElementCategory.IMPLIES_TYPE) != 0;
 
-  /** See [ErroneousElement] for documentation. */
-  bool get isErroneous => false;
-
-  /** See [AmbiguousElement] for documentation. */
-  bool get isAmbiguous => false;
-
-  /** See [WarnOnUseElement] for documentation. */
-  bool get isWarnOnUse => false;
-
   bool get isPatched => false;
 
   bool get isPatch => false;
 
   bool get isImplementation => true;
 
   bool get isDeclaration => true;
 
   bool get isInjected => !isPatch && implementationLibrary.isPatch;
 
@@ skipping 75 matching lines @@
     return null;
   }
 
   Element get enclosingClassOrCompilationUnit {
    for (Element e = this; e != null; e = e.enclosingElement) {
       if (e.isClass || e.isCompilationUnit) return e;
     }
     return null;
   }
 
-  /**
-   * Returns the member enclosing this element or the element itself if it is a
-   * member. If no enclosing element is found, [:null:] is returned.
-   */
-  Element get enclosingMember {
-    for (Element e = this; e != null; e = e.enclosingElement) {
-      if (e.isClassMember) return e;
-    }
-    return null;
-  }
-
   Element get outermostEnclosingMemberOrTopLevel {
     // TODO(lrn): Why is this called "Outermost"?
     // TODO(johnniwinther): Clean up this method: This method does not return
     // the outermost for elements in closure classses, but some call-sites rely
     // on that behavior.
     for (Element e = this; e != null; e = e.enclosingElement) {
       if (e.isClassMember || e.isTopLevel) {
         return e;
       }
     }
@@ skipping 56 matching lines @@
 
   TreeElements get treeElements => analyzableElement.treeElements;
 
   AnalyzableElement get analyzableElement {
     Element element = outermostEnclosingMemberOrTopLevel;
     if (element.isAbstractField || element.isPrefix) return element.library;
     return element;
   }
 }
 
-/**
- * Represents an unresolvable or duplicated element.
- *
- * 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
- * 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.isInvalid(element) :]
- * to check for unresolvable elements instead of
- *   [: element == null :].
- */
 class ErroneousElementX extends ElementX implements ErroneousElement {
   final MessageKind messageKind;
   final Map messageArguments;
 
   ErroneousElementX(this.messageKind, this.messageArguments,
                     String name, Element enclosing)
       : super(name, ElementKind.ERROR, enclosing);
 
-  bool get isErroneous => true;
-
   bool get isSynthesized => true;
 
   AbstractFieldElement abstractField;
 
   unsupported() {
     throw 'unsupported operation on erroneous element';
   }
 
   Link<MetadataAnnotation> get metadata => unsupported();
   bool get hasNode => false;
@@ skipping 41 matching lines @@
   final MessageKind messageKind;
 
   /**
    * The message arguments to report on resolving a wrapped element.
    */
   final Map messageArguments;
 
   WrappedMessage(this.spannable, this.messageKind, this.messageArguments);
 }
 
-/**
- * An [Element] whose reference should cause one or more warnings.
- */
 class WarnOnUseElementX extends ElementX implements WarnOnUseElement {
   /// Warning to report on resolving this element.
   final WrappedMessage warning;
 
   /// Info to report on resolving this element.
   final WrappedMessage info;
 
   /// The element whose usage cause a warning.
   final Element wrappedElement;
 
   WarnOnUseElementX(WrappedMessage this.warning, WrappedMessage this.info,
                     Element enclosingElement, Element wrappedElement)
       : this.wrappedElement = wrappedElement,
         super(wrappedElement.name, ElementKind.WARN_ON_USE, enclosingElement);
 
-  bool get isWarnOnUse => true;
-
   Element unwrap(DiagnosticListener listener, Spannable usageSpannable) {
     var unwrapped = wrappedElement;
     if (warning != null) {
       Spannable spannable = warning.spannable;
       if (spannable == null) spannable = usageSpannable;
       listener.reportWarning(
           spannable, warning.messageKind, warning.messageArguments);
     }
     if (info != null) {
       Spannable spannable = info.spannable;
       if (spannable == null) spannable = usageSpannable;
       listener.reportInfo(
           spannable, info.messageKind, info.messageArguments);
     }
     if (unwrapped.isWarnOnUse) {
       unwrapped = unwrapped.unwrap(listener, usageSpannable);
     }
     return unwrapped;
   }
 
   accept(ElementVisitor visitor) => visitor.visitWarnOnUseElement(this);
 }
 
-/**
- * An ambiguous element represents multiple elements accessible by the same name.
- *
- * Ambiguous elements are created during handling of import/export scopes. If an
- * ambiguous element is encountered during resolution a warning/error should be
- * reported.
- */
 class AmbiguousElementX extends ElementX implements AmbiguousElement {
   /**
    * The message to report on resolving this element.
    */
   final MessageKind messageKind;
 
   /**
    * The message arguments to report on resolving this element.
    */
   final Map messageArguments;
 
   /**
    * The first element that this ambiguous element might refer to.
    */
   final Element existingElement;
 
   /**
    * The second element that this ambiguous element might refer to.
    */
   final Element newElement;
 
   AmbiguousElementX(this.messageKind, this.messageArguments,
       Element enclosingElement, Element existingElement, Element newElement)
       : this.existingElement = existingElement,
         this.newElement = newElement,
         super(existingElement.name, ElementKind.AMBIGUOUS, enclosingElement);
 
-  bool get isAmbiguous => true;
-
   Setlet flatten() {
     Element element = this;
     var set = new Setlet();
     while (element.isAmbiguous) {
       AmbiguousElement ambiguous = element;
       set.add(ambiguous.newElement);
       element = ambiguous.existingElement;
     }
     set.add(element);
     return set;
@@ skipping 2258 matching lines @@
   AstElement get definingElement;
 
   bool get hasResolvedAst => definingElement.hasTreeElements;
 
   ResolvedAst get resolvedAst {
     return new ResolvedAst(declaration,
         definingElement.node, definingElement.treeElements);
   }
 
 }