anchor.diff:    ExecutableElement get enclosingElement;
   }
   
  -/**
  - * A library.
  - *
  - * Clients may not extend, implement or mix-in this class.
  - */
  +/// A library.
  +///
  +/// Clients may not extend, implement or mix-in this class.
   abstract class LibraryElement implements Element {
  -  /**
  -   * An empty list of library elements.
  -   */
  +  /// An empty list of library elements.
     @deprecated
     static const List<LibraryElement> EMPTY_LIST = const <LibraryElement>[];
   
  -  /**
  -   * Return the compilation unit that defines this library.
  -   */
  +  /// 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`.
  -   */
  +  /// 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.
  -   */
  +  /// 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.
  -   */
  +  /// 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.
  -   */
  +  /// 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.
  -   */
  +  /// 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`.
  -   */
  +  /// 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.
  -   */
  +  /// 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.
  -   */
  +  /// 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.
  -   */
  +  /// 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.
  -   */
  +  /// 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.
  -   */
  +  /// Return `true` if this library is the dart:async library.
     bool get isDartAsync;
   
  -  /**
  -   * Return `true` if this library is the dart:core library.
  -   */
  +  /// Return `true` if this library is the dart:core library.
     bool get isDartCore;
   
  -  /**
  -   * Return `true` if this library is part of the SDK.
  -   */
  +  /// 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.
  -   */
  +  /// 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.
  -   */
  +  /// 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.
  -   */
  +  /// 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.
  -   */
  +  /// 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.
  -   */
  +  /// 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.
  -   */
  +  /// 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.
  -   */
  +  /// 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.
  -   */
  +  /// 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.
  - */
  +/// 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.
  -   */
  +  /// 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.
  - */
  +/// 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.
  -   */
  +  /// 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.
  - */
  +/// 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.
  -   */
  +  /// 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`.
  -   */
  +  /// 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.
  - */
  +/// 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.
  -   */
  +  /// 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.
  -   */
  +  /// 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.
  - */
  +/// 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.
  -   */
  +  /// 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.
  - */
  +/// 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.
  -   */
  +  /// 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.
  - */
  +/// 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.
  -   */
  +  /// 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.
  -   */
  +  /// 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.
  -   */
  +  /// 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.
  -   */
  +  /// 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.
  -   */
  +  /// 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.
  -   */
  +  /// 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.
  -   */
  +  /// 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.
  -   */
  +  /// 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.
  -   */
  +  /// 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.
  -   */
  +  /// 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.
  -   */
  +  /// 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.
  -   */
  +  /// 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].
  -   */
  +  /// 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.
  - */
  +/// 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.
  -   */
  +  /// 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.
  -   */
  +  /// 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.
  - */
  +/// 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.
  -   */
  +  /// 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.
  -   */
  +  /// 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.
  -   */
  +  /// 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.
  -   */
  +  /// Return `true` if this accessor represents a getter.
     bool get isGetter;
   
  -  /**
  -   * Return `true` if this accessor represents a setter.
  -   */
  +  /// 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.
  -   */
  +  /// 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.
  - */
  +/// 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.
  -   */
  +  /// 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.
  -   */
  +  /// 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.
  -   */
  +  /// 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.
  -   */
  +  /// 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.
  - */
  +/// 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.
  -   */
  +  /// 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.
  -   */
  +  /// 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.
  -   */
  +  /// 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.
  - */
  +/// 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.
  -   */
  +  /// An empty list of top-level variable elements.
     @deprecated
     static const List<TopLevelVariableElement> EMPTY_LIST =
         const <TopLevelVariableElement>[];
  
positive.code:   FunctionType instantiate(List<DartType> argumentTypes);
  }
  
  /**
   * An element that has a [FunctionType] as its [type].
   *
   * This also provides convenient access to the parameters and return type.
   *
   * Clients may not extend, implement or mix-in this class.
   */
  abstract class FunctionTypedElement implements TypeParameterizedElement {
    /**
     * Return a list containing all of the parameters defined by this executable
     * element.
     */
    List<ParameterElement> get parameters;
  
    /**
     * Return the return type defined by this element. If the element model is
     * fully populated, then the [returnType] will not be `null`, even if no
     * return type was explicitly specified.
     */
    DartType get returnType;
  
    @override
    FunctionType get type;
  }
  
  /**
   * The pseudo-declaration that defines a generic function type.
   *
   * Clients may not extend, implement, or mix-in this class.
   */
  abstract class GenericFunctionTypeElement implements FunctionTypedElement {}
  
  /**
   * A [FunctionTypeAliasElement] whose returned function type has a [type]
   * parameter.
   *
   * Clients may not extend, implement, or mix-in this class.
   */
  abstract class GenericTypeAliasElement implements FunctionTypeAliasElement {
    /**
     * Return the generic function type element representing the generic function
     * type on the right side of the equals.
     */
    GenericFunctionTypeElement get function;
  }
  
  /**
   * A combinator that causes some of the names in a namespace to be hidden when
   * being imported.
   *
   * Clients may not extend, implement or mix-in this class.
   */
  abstract class HideElementCombinator implements NamespaceCombinator {
    /**
     * Return a list containing the names that are not to be made visible in the
     * importing library even if they are defined in the imported library.
     */
    List<String> get hiddenNames;
  }
  
  /**
   * A single import directive within a library.
   *
   * Clients may not extend, implement or mix-in this class.
   */
  abstract class ImportElement implements Element, UriReferencedElement {
    /**
     * An empty list of import elements.
     */
    @deprecated
    static const List<ImportElement> EMPTY_LIST = const <ImportElement>[];
  
    /**
     * Return a list containing the combinators that were specified as part of the
     * import directive in the order in which they were specified.
     */
    List<NamespaceCombinator> get combinators;
  
    /**
     * Return the library that is imported into this library by this import
     * directive.
     */
    LibraryElement get importedLibrary;
  
    /**
     * Return `true` if this import is for a deferred library.
     */
    bool get isDeferred;
  
    /**
     * The [Namespace] that this directive contributes to the containing library.
     */
    Namespace get namespace;
  
    /**
     * Return the prefix that was specified as part of the import directive, or
     * `null` if there was no prefix specified.
     */
    PrefixElement get prefix;
  
    /**
     * Return the offset of the prefix of this import in the file that contains
     * this import directive, or `-1` if this import is synthetic, does not have a
     * prefix, or otherwise does not have an offset.
     */
    int get prefixOffset;
  }
  
  /**
   * A label associated with a statement.
   *
   * Clients may not extend, implement or mix-in this class.
   */
  abstract class LabelElement implements Element {
    /**
     * An empty list of label elements.
     */
    @deprecated
    static const List<LabelElement> EMPTY_LIST = const <LabelElement>[];
  
  
negative.code:   @override
    String toString() => name;
  
    /// Return the kind of the given [element], or [ERROR] if the element is
    /// `null`. This is a utility method that can reduce the need for null checks
    /// in other places.
    static ElementKind of(Element element) {
      if (element == null) {
        return ERROR;
  