anchor.diff:    @deprecated
     bool get isVisibleForTesting;
   
  -  /**
  -   * Return the kind of element that this is.
  -   */
  +  /// 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.
  -   */
  +  /// 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.
  -   */
  +  /// 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.
  -   */
  +  /// 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.
  -   */
  +  /// 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.
  -   */
  +  /// 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.
  -   */
  +  /// 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.
  -   */
  +  /// 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.
  -   */
  +  /// 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.
  -   */
  +  /// 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.
  -   */
  +  /// 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.
  -   */
  +  /// 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.
  -   */
  +  /// 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>
  -   */
  +  /// 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.
  -   */
  +  /// 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.
  - */
  +/// 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.
  -   */
  +  /// 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.
  -   */
  +  /// 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.
  -   */
  +  /// 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.
  -   */
  +  /// 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.
  -   */
  +  /// 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.
  -   */
  +  /// 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.
  -   */
  +  /// 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.
  -   */
  +  /// 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.
  -   */
  +  /// 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.
  -   */
  +  /// 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.
  -   */
  +  /// 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.
  -   */
  +  /// 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.
  -   */
  +  /// 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.
  -   */
  +  /// 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.
  -   */
  +  /// 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.
  -   */
  +  /// 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.
  -   */
  +  /// 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.
  -   */
  +  /// 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.
  -   */
  +  /// 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.
  -   */
  +  /// 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.
  - */
  +/// 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");
   
  
positive.code:   ExecutableElement get enclosingElement;
  }
  
  /**
   * A library.
   *
   * Clients may not extend, implement or mix-in this class.
   */
  abstract class LibraryElement implements Element {
    /**
     * An empty list of library elements.
     */
    @deprecated
    static const List<LibraryElement> EMPTY_LIST = const <LibraryElement>[];
  
    /**
     * Return the compilation unit that defines this library.
     */
    CompilationUnitElement get definingCompilationUnit;
  
    /**
     * Return the entry point for this library, or `null` if this library does not
     * have an entry point. The entry point is defined to be a zero argument
     * top-level function whose name is `main`.
     */
    FunctionElement get entryPoint;
  
    /**
     * Return a list containing all of the libraries that are exported from this
     * library.
     */
    List<LibraryElement> get exportedLibraries;
  
    /**
     * The export [Namespace] of this library, `null` if it has not been
     * computed yet.
     */
    Namespace get exportNamespace;
  
    /**
     * Return a list containing all of the exports defined in this library.
     */
    List<ExportElement> get exports;
  
    /**
     * Return `true` if the defining compilation unit of this library contains at
     * least one import directive whose URI uses the "dart-ext" scheme.
     */
    bool get hasExtUri;
  
    /**
     * Return `true` if this library defines a top-level function named
     * `loadLibrary`.
     */
    bool get hasLoadLibraryFunction;
  
    /**
     * Return an identifier that uniquely identifies this element among the
     * children of this element's parent.
     */
    String get identifier;
  
    /**
     * Return a list containing all of the libraries that are imported into this
     * library. This includes all of the libraries that are imported using a
     * prefix (also available through the prefixes returned by [getPrefixes]) and
     * those that are imported without a prefix.
     */
    List<LibraryElement> get importedLibraries;
  
    /**
     * Return a list containing all of the imports defined in this library.
     */
    List<ImportElement> get imports;
  
    /**
     * Return `true` if this library is an application that can be run in the
     * browser.
     */
    bool get isBrowserApplication;
  
    /**
     * Return `true` if this library is the dart:async library.
     */
    bool get isDartAsync;
  
    /**
     * Return `true` if this library is the dart:core library.
     */
    bool get isDartCore;
  
    /**
     * Return `true` if this library is part of the SDK.
     */
    bool get isInSdk;
  
    /**
     * Return a list containing the strongly connected component in the
     * import/export graph in which the current library resides.
     */
    List<LibraryElement> get libraryCycle;
  
    /**
     * Return the element representing the synthetic function `loadLibrary` that
     * is implicitly defined for this library if the library is imported using a
     * deferred import.
     */
    FunctionElement get loadLibraryFunction;
  
    /**
     * Return a list containing all of the compilation units that are included in
     * this library using a `part` directive. This does not include the defining
     * compilation unit that contains the `part` directives.
     */
    List<CompilationUnitElement> get parts;
  
    /**
     * Return a list containing elements for each of the prefixes used to `import`
     * libraries into this library. Each prefix can be used in more than one
     * `import` directive.
     */
    List<PrefixElement> get prefixes;
  
    /**
     * The public [Namespace] of this library, `null` if it has not been
     * computed yet.
     */
    Namespace get publicNamespace;
  
    /**
     * Return a list containing all of the compilation units this library consists
     * of. This includes the defining compilation unit and units included using
     * the `part` directive.
     */
    List<CompilationUnitElement> get units;
  
    /**
     * Return a list containing all of the imports that share the given [prefix],
     * or an empty array if there are no such imports.
     */
    List<ImportElement> getImportsWithPrefix(PrefixElement prefix);
  
    /**
     * Return the class defined in this library that has the given [name], or
     * `null` if this library does not define a class with the given name.
     */
    ClassElement getType(String className);
  }
  
  /**
   * An element that can be (but is not required to be) defined within a method
   * or function (an [ExecutableElement]).
   *
   * Clients may not extend, implement or mix-in this class.
   */
  abstract class LocalElement implements Element {
    /**
     * Return a source range that covers the approximate portion of the source in
     * which the name of this element is visible, or `null` if there is no single
     * range of characters within which the element name is visible.
     *
     * * For a local variable, this is the source range of the block that
     *   encloses the variable declaration.
     * * For a parameter, this includes the body of the method or function that
     *   declares the parameter.
     * * For a local function, this is the source range of the block that
     *   encloses the variable declaration.
     * * For top-level functions, `null` will be returned because they are
     *   potentially visible in multiple sources.
     */
    SourceRange get visibleRange;
  }
  
  /**
   * A local variable.
   *
   * Clients may not extend, implement or mix-in this class.
   */
  abstract class LocalVariableElement implements LocalElement, VariableElement {
    /**
     * An empty list of field elements.
     */
    @deprecated
    static const List<LocalVariableElement> EMPTY_LIST =
        const <LocalVariableElement>[];
  }
  
  /**
   * An element that represents a method defined within a type.
   *
   * Clients may not extend, implement or mix-in this class.
   */
  abstract class MethodElement implements ClassMemberElement, ExecutableElement {
    /**
     * An empty list of method elements.
     */
    @deprecated
    static const List<MethodElement> EMPTY_LIST = const <MethodElement>[];
  
    @override
    MethodDeclaration computeNode();
  
    /**
     * Gets the reified type of a tear-off of this method.
     *
     * If any of the parameters in the method are covariant, they are replaced
     * with Object in the returned type. If no covariant parameters are present,
     * returns `this`.
     */
    @deprecated
    FunctionType getReifiedType(DartType objectType);
  }
  
  /**
   * A pseudo-element that represents multiple elements defined within a single
   * scope that have the same name. This situation is not allowed by the language,
   * so objects implementing this interface always represent an error. As a
   * result, most of the normal operations on elements do not make sense and will
   * return useless results.
   *
   * Clients may not extend, implement or mix-in this class.
   */
  abstract class MultiplyDefinedElement implements Element {
    /**
     * Return a list containing all of the elements that were defined within the
     * scope to have the same name.
     */
    List<Element> get conflictingElements;
  
    /**
     * Return the type of this element as the dynamic type.
     */
    DartType get type;
  }
  
  /**
   * An [ExecutableElement], with the additional information of a list of
   * [ExecutableElement]s from which this element was composed.
   *
   * Clients may not extend, implement or mix-in this class.
   */
  abstract class MultiplyInheritedExecutableElement implements ExecutableElement {
    /**
     * Return a list containing all of the executable elements defined within this
     * executable element.
     */
    List<ExecutableElement> get inheritedElements;
  }
  
  /**
   * An object that controls how namespaces are combined.
   *
   * Clients may not extend, implement or mix-in this class.
   */
  abstract class NamespaceCombinator {
    /**
     * An empty list of namespace combinators.
     */
    @deprecated
    static const List<NamespaceCombinator> EMPTY_LIST =
        const <NamespaceCombinator>[];
  }
  
  /**
   * A parameter defined within an executable element.
   *
   * Clients may not extend, implement or mix-in this class.
   */
  abstract class ParameterElement
      implements LocalElement, VariableElement, ConstantEvaluationTarget {
    /**
     * An empty list of parameter elements.
     */
    @deprecated
    static const List<ParameterElement> EMPTY_LIST = const <ParameterElement>[];
  
    /**
     * Return the Dart code of the default value, or `null` if no default value.
     */
    String get defaultValueCode;
  
    /**
     * Return `true` if this parameter is covariant, meaning it is allowed to have
     * a narrower type in an override.
     */
    bool get isCovariant;
  
    /**
     * Return `true` if this parameter is an initializing formal parameter.
     */
    bool get isInitializingFormal;
  
    /**
     * Return `true` if this parameter is a named parameter. Named parameters are
     * always optional, even when they are annotated with the `@required`
     * annotation.
     */
    bool get isNamed;
  
    /**
     * Return `true` if this parameter is a required parameter. Required
     * parameters are always positional.
     *
     * Note: this will return `false` for a named parameter that is annotated with
     * the `@required` annotation.
     */
    // TODO(brianwilkerson) Rename this to `isRequired`.
    bool get isNotOptional;
  
    /**
     * Return `true` if this parameter is an optional parameter. Optional
     * parameters can either be positional or named.
     */
    bool get isOptional;
  
    /**
     * Return `true` if this parameter is both an optional and positional
     * parameter.
     */
    bool get isOptionalPositional;
  
    /**
     * Return `true` if this parameter is a positional parameter. Positional
     * parameters can either be required or optional.
     */
    bool get isPositional;
  
    /**
     * Return the kind of this parameter.
     */
    @deprecated
    ParameterKind get parameterKind;
  
    /**
     * Return a list containing all of the parameters defined by this parameter.
     * A parameter will only define other parameters if it is a function typed
     * parameter.
     */
    List<ParameterElement> get parameters;
  
    /**
     * Return a list containing all of the type parameters defined by this
     * parameter. A parameter will only define other parameters if it is a
     * function typed parameter.
     */
    List<TypeParameterElement> get typeParameters;
  
    /**
     * Append the type, name and possibly the default value of this parameter to
     * the given [buffer].
     */
    void appendToWithoutDelimiters(StringBuffer buffer);
  
    @override
    FormalParameter computeNode();
  }
  
  /**
   * A prefix used to import one or more libraries into another library.
   *
   * Clients may not extend, implement or mix-in this class.
   */
  abstract class PrefixElement implements Element {
    /**
     * An empty list of prefix elements.
     */
    @deprecated
    static const List<PrefixElement> EMPTY_LIST = const <PrefixElement>[];
  
    @override
    LibraryElement get enclosingElement;
  
    /**
     * Return the empty list.
     *
     * Deprecated: this getter was intended to return a list containing all of
     * the libraries that are imported using this prefix, but it was never
     * implemented.  Due to lack of demand, it is being removed.
     */
    @deprecated
    List<LibraryElement> get importedLibraries;
  }
  
  /**
   * A getter or a setter. Note that explicitly defined property accessors
   * implicitly define a synthetic field. Symmetrically, synthetic accessors are
   * implicitly created for explicitly defined fields. The following rules apply:
   *
   * * Every explicit field is represented by a non-synthetic [FieldElement].
   * * Every explicit field induces a getter and possibly a setter, both of which
   *   are represented by synthetic [PropertyAccessorElement]s.
   * * Every explicit getter or setter is represented by a non-synthetic
   *   [PropertyAccessorElement].
   * * Every explicit getter or setter (or pair thereof if they have the same
   *   name) induces a field that is represented by a synthetic [FieldElement].
   *
   * Clients may not extend, implement or mix-in this class.
   */
  abstract class PropertyAccessorElement implements ExecutableElement {
    /**
     * An empty list of property accessor elements.
     */
    @deprecated
    static const List<PropertyAccessorElement> EMPTY_LIST =
        const <PropertyAccessorElement>[];
  
    /**
     * Return the accessor representing the getter that corresponds to (has the
     * same name as) this setter, or `null` if this accessor is not a setter or if
     * there is no corresponding getter.
     */
    PropertyAccessorElement get correspondingGetter;
  
    /**
     * Return the accessor representing the setter that corresponds to (has the
     * same name as) this getter, or `null` if this accessor is not a getter or if
     * there is no corresponding setter.
     */
    PropertyAccessorElement get correspondingSetter;
  
    /**
     * Return `true` if this accessor represents a getter.
     */
    bool get isGetter;
  
    /**
     * Return `true` if this accessor represents a setter.
     */
    bool get isSetter;
  
    /**
     * Return the field or top-level variable associated with this accessor. If
     * this accessor was explicitly defined (is not synthetic) then the variable
     * associated with it will be synthetic.
     */
    PropertyInducingElement get variable;
  }
  
  /**
   * A variable that has an associated getter and possibly a setter. Note that
   * explicitly defined variables implicitly define a synthetic getter and that
   * non-`final` explicitly defined variables implicitly define a synthetic
   * setter. Symmetrically, synthetic fields are implicitly created for explicitly
   * defined getters and setters. The following rules apply:
   *
   * * Every explicit variable is represented by a non-synthetic
   *   [PropertyInducingElement].
   * * Every explicit variable induces a getter and possibly a setter, both of
   *   which are represented by synthetic [PropertyAccessorElement]s.
   * * Every explicit getter or setter is represented by a non-synthetic
   *   [PropertyAccessorElement].
   * * Every explicit getter or setter (or pair thereof if they have the same
   *   name) induces a variable that is represented by a synthetic
   *   [PropertyInducingElement].
   *
   * Clients may not extend, implement or mix-in this class.
   */
  abstract class PropertyInducingElement implements VariableElement {
    /**
     * An empty list of elements.
     */
    @deprecated
    static const List<PropertyInducingElement> EMPTY_LIST =
        const <PropertyInducingElement>[];
  
    /**
     * Return the getter associated with this variable. If this variable was
     * explicitly defined (is not synthetic) then the getter associated with it
     * will be synthetic.
     */
    PropertyAccessorElement get getter;
  
    /**
     * Return the propagated type of this variable, or `null` if type propagation
     * has not been performed, for example because the variable is not final.
     */
    @deprecated
    DartType get propagatedType;
  
    /**
     * Return the setter associated with this variable, or `null` if the variable
     * is effectively `final` and therefore does not have a setter associated with
     * it. (This can happen either because the variable is explicitly defined as
     * being `final` or because the variable is induced by an explicit getter that
     * does not have a corresponding setter.) If this variable was explicitly
     * defined (is not synthetic) then the setter associated with it will be
     * synthetic.
     */
    PropertyAccessorElement get setter;
  }
  
  /**
   * A combinator that cause some of the names in a namespace to be visible (and
   * the rest hidden) when being imported.
   *
   * Clients may not extend, implement or mix-in this class.
   */
  abstract class ShowElementCombinator implements NamespaceCombinator {
    /**
     * Return the offset of the character immediately following the last character
     * of this node.
     */
    int get end;
  
    /**
     * Return the offset of the 'show' keyword of this element.
     */
    int get offset;
  
    /**
     * Return a list containing the names that are to be made visible in the
     * importing library if they are defined in the imported library.
     */
    List<String> get shownNames;
  }
  
  /**
   * A top-level variable.
   *
   * Clients may not extend, implement or mix-in this class.
   */
  abstract class TopLevelVariableElement implements PropertyInducingElement {
    /**
     * An empty list of top-level variable elements.
     */
    @deprecated
    static const List<TopLevelVariableElement> EMPTY_LIST =
        const <TopLevelVariableElement>[];
  
negative.code:   }
  }
  
  /// 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.
    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.
    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.
  abstract class ElementVisitor<R> {
    R visitClassElement(ClassElement element);
  
  