anchor.diff:    }
   }
   
  -/**
  - * The location of an element within the element model.
  - *
  - * Clients may not extend, implement or mix-in this class.
  - */
  +/// The location of an element within the element model.
  +///
  +/// Clients may not extend, implement or mix-in this class.
   abstract class ElementLocation {
  -  /**
  -   * Return the path to the element whose location is represented by this
  -   * object. Clients must not modify the returned array.
  -   */
  +  /// Return the path to the element whose location is represented by this
  +  /// object. Clients must not modify the returned array.
     List<String> get components;
   
  -  /**
  -   * Return an encoded representation of this location that can be used to
  -   * create a location that is equal to this location.
  -   */
  +  /// Return an encoded representation of this location that can be used to
  +  /// create a location that is equal to this location.
     String get encoding;
   }
   
  -/**
  - * An object that can be used to visit an element structure.
  - *
  - * Clients may not extend, implement or mix-in this class. There are classes
  - * that implement this interface that provide useful default behaviors in
  - * `package:analyzer/dart/ast/visitor.dart`. A couple of the most useful include
  - * * SimpleElementVisitor which implements every visit method by doing nothing,
  - * * RecursiveElementVisitor which will cause every node in a structure to be
  - *   visited, and
  - * * ThrowingElementVisitor which implements every visit method by throwing an
  - *   exception.
  - */
  +/// An object that can be used to visit an element structure.
  +///
  +/// Clients may not extend, implement or mix-in this class. There are classes
  +/// that implement this interface that provide useful default behaviors in
  +/// `package:analyzer/dart/ast/visitor.dart`. A couple of the most useful
  +/// include
  +/// * SimpleElementVisitor which implements every visit method by doing nothing,
  +/// * RecursiveElementVisitor which will cause every node in a structure to be
  +///   visited, and
  +/// * ThrowingElementVisitor which implements every visit method by throwing an
  +///   exception.
   abstract class ElementVisitor<R> {
     R visitClassElement(ClassElement element);
   
  
positive.code:   AstNode computeNode();
  }
  
  /**
   * A field formal parameter defined within a constructor element.
   *
   * Clients may not extend, implement or mix-in this class.
   */
  abstract class FieldFormalParameterElement implements ParameterElement {
    /**
     * Return the field element associated with this field formal parameter, or
     * `null` if the parameter references a field that doesn't exist.
     */
    FieldElement get field;
  }
  
  /**
   * A (non-method) function. This can be either a top-level function, a local
   * function, a closure, or the initialization expression for a field or
   * variable.
   *
   * Clients may not extend, implement or mix-in this class.
   */
  abstract class FunctionElement implements ExecutableElement, LocalElement {
    /**
     * An empty list of function elements.
     */
    @deprecated
    static const List<FunctionElement> EMPTY_LIST = const <FunctionElement>[];
  
    /**
     * The name of the method that can be implemented by a class to allow its
     * instances to be invoked as if they were a function.
     */
    static final String CALL_METHOD_NAME = "call";
  
    /**
     * The name of the synthetic function defined for libraries that are deferred.
     */
    static final String LOAD_LIBRARY_NAME = "loadLibrary";
  
    /**
     * The name of the function used as an entry point.
     */
    static const String MAIN_FUNCTION_NAME = "main";
  
    /**
     * The name of the method that will be invoked if an attempt is made to invoke
     * an undefined method on an object.
     */
    static final String NO_SUCH_METHOD_METHOD_NAME = "noSuchMethod";
  
    /**
     * Return `true` if the function is an entry point, i.e. a top-level function
     * and has the name `main`.
     */
    bool get isEntryPoint;
  
    @override
    FunctionDeclaration computeNode();
  }
  
  /**
   * A function type alias (`typedef`).
   *
   * Clients may not extend, implement or mix-in this class.
   */
  abstract class FunctionTypeAliasElement
      implements FunctionTypedElement, TypeDefiningElement {
    /**
     * An empty array of type alias elements.
     */
    @deprecated
    static List<FunctionTypeAliasElement> EMPTY_LIST =
        new List<FunctionTypeAliasElement>(0);
  
negative.code:   @deprecated
    bool get isVisibleForTesting;
  
    /// Return the kind of element that this is.
    ElementKind get kind;
  
    /// Return the library that contains this element. This will be the element
    /// itself if it is a library element. This will be `null` if this element is
    /// an HTML file because HTML files are not contained in libraries.
    LibraryElement get library;
  
    /// Return an object representing the location of this element in the element
    /// model. The object can be used to locate this element at a later time.
    ElementLocation get location;
  
    /// Return a list containing all of the metadata associated with this element.
    /// The array will be empty if the element does not have any metadata or if
    /// the library containing this element has not yet been resolved.
    List<ElementAnnotation> get metadata;
  
    /// Return the name of this element, or `null` if this element does not have a
    /// name.
    String get name;
  
    /// Return the length of the name of this element in the file that contains
    /// the declaration of this element, or `0` if this element does not have a
    /// name.
    int get nameLength;
  
    /// Return the offset of the name of this element in the file that contains
    /// the declaration of this element, or `-1` if this element is synthetic,
    /// does not have a name, or otherwise does not have an offset.
    int get nameOffset;
  
    @override
    Source get source;
  
    /// Return the resolved [CompilationUnit] that declares this element, or
    /// `null` if this element is synthetic.
    ///
    /// This method is expensive, because resolved AST might have been already
    /// evicted from cache, so parsing and resolving will be performed.
    CompilationUnit get unit;
  
    /// Use the given [visitor] to visit this element. Return the value returned
    /// by the visitor as a result of visiting this element.
    T accept<T>(ElementVisitor<T> visitor);
  
    /// Return the documentation comment for this element as it appears in the
    /// original source (complete with the beginning and ending delimiters), or
    /// `null` if this element does not have a documentation comment associated
    /// with it. This can be a long-running operation if the information needed to
    /// access the comment is not cached.
    ///
    /// Throws [AnalysisException] if the documentation comment could not be
    /// determined because the analysis could not be performed
    ///
    /// Deprecated.  Use [documentationComment] instead.
    @deprecated
    String computeDocumentationComment();
  
    /// Return the resolved [AstNode] node that declares this element, or `null`
    /// if this element is synthetic or isn't contained in a compilation unit,
    /// such as a [LibraryElement].
    ///
    /// This method is expensive, because resolved AST might be evicted from
    /// cache, so parsing and resolving will be performed.
    ///
    /// <b>Note:</b> This method cannot be used in an async environment.
    AstNode computeNode();
  
    /// Return the most immediate ancestor of this element for which the
    /// [predicate] returns `true`, or `null` if there is no such ancestor. Note
    /// that this element will never be returned.
    E getAncestor<E extends Element>(Predicate<Element> predicate);
  
    /// Return a display name for the given element that includes the path to the
    /// compilation unit in which the type is defined. If [shortName] is `null`
    /// then [displayName] will be used as the name of this element. Otherwise
    /// the provided name will be used.
    // TODO(brianwilkerson) Make the parameter optional.
    String getExtendedDisplayName(String shortName);
  
    /// Return `true` if this element, assuming that it is within scope, is
    /// accessible to code in the given [library]. This is defined by the Dart
    /// Language Specification in section 3.2:
    /// <blockquote>
    /// A declaration <i>m</i> is accessible to library <i>L</i> if <i>m</i> is
    /// declared in <i>L</i> or if <i>m</i> is public.
    /// </blockquote>
    bool isAccessibleIn(LibraryElement library);
  
    /// Use the given [visitor] to visit all of the children of this element.
    /// There is no guarantee of the order in which the children will be visited.
    void visitChildren(ElementVisitor visitor);
  }
  
  /// A single annotation associated with an element.
  ///
  /// Clients may not extend, implement or mix-in this class.
  abstract class ElementAnnotation implements ConstantEvaluationTarget {
    /// An empty list of annotations.
    @deprecated
    static const List<ElementAnnotation> EMPTY_LIST = const <ElementAnnotation>[];
  
    /// Return a representation of the value of this annotation.
    ///
    /// Return `null` if the value of this annotation could not be computed
    /// because of errors.
    DartObject get constantValue;
  
    /// Return the element representing the field, variable, or const constructor
    /// being used as an annotation.
    Element get element;
  
    /// Return `true` if this annotation marks the associated function as always
    /// throwing.
    bool get isAlwaysThrows;
  
    /// Return `true` if this annotation marks the associated element as being
    /// deprecated.
    bool get isDeprecated;
  
    /// Return `true` if this annotation marks the associated member as a factory.
    bool get isFactory;
  
    /// Return `true` if this annotation marks the associated class and its
    /// subclasses as being immutable.
    bool get isImmutable;
  
    /// Return `true` if this annotation marks the associated member as running
    /// a single test.
    bool get isIsTest;
  
    /// Return `true` if this annotation marks the associated member as running
    /// a test group.
    bool get isIsTestGroup;
  
    /// Return `true` if this annotation marks the associated element with the
    /// `JS` annotation.
    bool get isJS;
  
    /// Return `true` if this annotation marks the associated member as requiring
    /// overriding methods to call super.
    bool get isMustCallSuper;
  
    /// Return `true` if this annotation marks the associated method as being
    /// expected to override an inherited method.
    bool get isOverride;
  
    /// Return `true` if this annotation marks the associated member as being
    /// protected.
    bool get isProtected;
  
    /// Return `true` if this annotation marks the associated class as
    /// implementing a proxy object.
    bool get isProxy;
  
    /// Return `true` if this annotation marks the associated member as being
    /// required.
    bool get isRequired;
  
    /// Return `true` if this annotation marks the associated class as being
    /// sealed.
    bool get isSealed;
  
    /// Return `true` if this annotation marks the associated member as being
    /// visible for template files.
    bool get isVisibleForTemplate;
  
    /// Return `true` if this annotation marks the associated member as being
    /// visible for testing.
    bool get isVisibleForTesting;
  
    /// Return a representation of the value of this annotation, forcing the value
    /// to be computed if it had not previously been computed, or `null` if the
    /// value of this annotation could not be computed because of errors.
    DartObject computeConstantValue();
  
    /// Return a textual description of this annotation in a form approximating
    /// valid source. The returned string will not be valid source primarily in
    /// the case where the annotation itself is not well-formed.
    String toSource();
  }
  
  /// The kind of elements in the element model.
  ///
  /// Clients may not extend, implement or mix-in this class.
  class ElementKind implements Comparable<ElementKind> {
    static const ElementKind CLASS = const ElementKind('CLASS', 0, "class");
  
  