Removed fixed dependencies

packages/analyzer/lib/src/dart/element/handle.dart

 // Copyright (c) 2014, 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 engine.element_handle;
+library analyzer.src.generated.element_handle;
 
-import 'package:analyzer/src/generated/ast.dart';
-import 'package:analyzer/src/generated/constant.dart';
-import 'package:analyzer/src/generated/element.dart';
+import 'package:analyzer/dart/ast/ast.dart';
+import 'package:analyzer/dart/constant/value.dart';
+import 'package:analyzer/dart/element/element.dart';
+import 'package:analyzer/dart/element/type.dart';
+import 'package:analyzer/src/dart/element/element.dart';
 import 'package:analyzer/src/generated/engine.dart';
-import 'package:analyzer/src/generated/java_core.dart';
 import 'package:analyzer/src/generated/java_engine.dart';
 import 'package:analyzer/src/generated/resolver.dart';
 import 'package:analyzer/src/generated/source.dart';
 import 'package:analyzer/src/generated/utilities_dart.dart';
 
 /**
- * Instances of the class `ClassElementHandle` implement a handle to a `ClassElement`.
+ * A handle to a [ClassElement].
  */
 class ClassElementHandle extends ElementHandle implements ClassElement {
   /**
-   * Initialize a newly created element handle to represent the given element.
-   *
-   * @param element the element being represented
+   * Initialize a newly created element handle to represent the element at the
+   * given [_location]. The [_resynthesizer] will be used to resynthesize the
+   * element when needed.
    */
-  ClassElementHandle(ClassElement element) : super(element);
+  ClassElementHandle(
+      ElementResynthesizer resynthesizer, ElementLocation location)
+      : super(resynthesizer, location);
 
   @override
   List<PropertyAccessorElement> get accessors => actualElement.accessors;
 
   @override
   ClassElement get actualElement => super.actualElement as ClassElement;
 
   @override
   List<InterfaceType> get allSupertypes => actualElement.allSupertypes;
 
@@ skipping 15 matching lines @@
   @override
   List<InterfaceType> get interfaces => actualElement.interfaces;
 
   @override
   bool get isAbstract => actualElement.isAbstract;
 
   @override
   bool get isEnum => actualElement.isEnum;
 
   @override
+  bool get isJS => actualElement.isJS;
+
+  @override
   bool get isMixinApplication => actualElement.isMixinApplication;
 
   @override
   bool get isOrInheritsProxy => actualElement.isOrInheritsProxy;
 
   @override
   bool get isProxy => actualElement.isProxy;
 
   @override
-  @deprecated
-  bool get isTypedef => actualElement.isMixinApplication;
+  bool get isRequired => actualElement.isRequired;
 
   @override
   bool get isValidMixin => actualElement.isValidMixin;
 
   @override
   ElementKind get kind => ElementKind.CLASS;
 
   @override
   List<MethodElement> get methods => actualElement.methods;
 
   @override
   List<InterfaceType> get mixins => actualElement.mixins;
 
   @override
   InterfaceType get supertype => actualElement.supertype;
 
   @override
   InterfaceType get type => actualElement.type;
 
   @override
   List<TypeParameterElement> get typeParameters => actualElement.typeParameters;
 
   @override
   ConstructorElement get unnamedConstructor => actualElement.unnamedConstructor;
 
   @override
+  NamedCompilationUnitMember computeNode() => super.computeNode();
+
+  @override
   FieldElement getField(String fieldName) => actualElement.getField(fieldName);
 
   @override
   PropertyAccessorElement getGetter(String getterName) =>
       actualElement.getGetter(getterName);
 
   @override
   MethodElement getMethod(String methodName) =>
       actualElement.getMethod(methodName);
 
@@ skipping 29 matching lines @@
           String methodName, LibraryElement library) =>
       actualElement.lookUpInheritedConcreteMethod(methodName, library);
 
   @override
   PropertyAccessorElement lookUpInheritedConcreteSetter(
           String methodName, LibraryElement library) =>
       actualElement.lookUpInheritedConcreteSetter(methodName, library);
 
   @override
   MethodElement lookUpInheritedMethod(
-          String methodName, LibraryElement library) =>
-      actualElement.lookUpInheritedMethod(methodName, library);
+      String methodName, LibraryElement library) {
+    return actualElement.lookUpInheritedMethod(methodName, library);
+  }
 
   @override
   MethodElement lookUpMethod(String methodName, LibraryElement library) =>
       actualElement.lookUpMethod(methodName, library);
 
   @override
   PropertyAccessorElement lookUpSetter(
           String setterName, LibraryElement library) =>
       actualElement.lookUpSetter(setterName, library);
 }
 
 /**
- * Instances of the class `CompilationUnitElementHandle` implements a handle to a
- * [CompilationUnitElement].
+ * A handle to a [CompilationUnitElement].
  */
 class CompilationUnitElementHandle extends ElementHandle
     implements CompilationUnitElement {
   /**
-   * Initialize a newly created element handle to represent the given element.
-   *
-   * @param element the element being represented
+   * Initialize a newly created element handle to represent the element at the
+   * given [_location]. The [_resynthesizer] will be used to resynthesize the
+   * element when needed.
    */
-  CompilationUnitElementHandle(CompilationUnitElement element) : super(element);
+  CompilationUnitElementHandle(
+      ElementResynthesizer resynthesizer, ElementLocation location)
+      : super(resynthesizer, location);
 
   @override
   List<PropertyAccessorElement> get accessors => actualElement.accessors;
 
   @override
   CompilationUnitElement get actualElement =>
       super.actualElement as CompilationUnitElement;
 
   @override
   LibraryElement get enclosingElement =>
@@ skipping 43 matching lines @@
   }
 
   @override
   ClassElement getEnum(String enumName) => actualElement.getEnum(enumName);
 
   @override
   ClassElement getType(String className) => actualElement.getType(className);
 }
 
 /**
- * Instances of the class `ConstructorElementHandle` implement a handle to a
- * `ConstructorElement`.
+ * A handle to a [ConstructorElement].
  */
 class ConstructorElementHandle extends ExecutableElementHandle
     implements ConstructorElement {
   /**
-   * Initialize a newly created element handle to represent the given element.
-   *
-   * @param element the element being represented
+   * Initialize a newly created element handle to represent the element at the
+   * given [_location]. The [_resynthesizer] will be used to resynthesize the
+   * element when needed.
    */
-  ConstructorElementHandle(ConstructorElement element) : super(element);
+  ConstructorElementHandle(
+      ElementResynthesizer resynthesizer, ElementLocation location)
+      : super(resynthesizer, location);
 
   @override
   ConstructorElement get actualElement =>
       super.actualElement as ConstructorElement;
 
   @override
   ClassElement get enclosingElement => actualElement.enclosingElement;
 
   @override
   bool get isConst => actualElement.isConst;
@@ skipping 15 matching lines @@
 
   @override
   ConstructorElement get redirectedConstructor =>
       actualElement.redirectedConstructor;
 
   @override
   ConstructorDeclaration computeNode() => actualElement.computeNode();
 }
 
 /**
- * The abstract class `ElementHandle` implements the behavior common to objects that implement
- * a handle to an [Element].
+ * A handle to an [Element].
  */
 abstract class ElementHandle implements Element {
   /**
    * The unique integer identifier of this element.
    */
   final int id = 0;
 
   /**
-   * The context in which the element is defined.
+   * The [ElementResynthesizer] which will be used to resynthesize elements on
+   * demand.
    */
-  AnalysisContext _context;
+  final ElementResynthesizer _resynthesizer;
 
   /**
-   * The location of this element, used to reconstitute the element if it has been garbage
-   * collected.
+   * The location of this element, used to reconstitute the element if it has
+   * not yet been resynthesized.
    */
-  ElementLocation _location;
+  final ElementLocation _location;
 
   /**
-   * A reference to the element being referenced by this handle, or `null` if the element has
-   * been garbage collected.
+   * A reference to the element being referenced by this handle, or `null` if
+   * the element has not yet been resynthesized.
    */
-  WeakReference<Element> _elementReference;
+  Element _elementReference;
 
   /**
-   * Initialize a newly created element handle to represent the given element.
-   *
-   * @param element the element being represented
+   * Initialize a newly created element handle to represent the element at the
+   * given [_location]. The [_resynthesizer] will be used to resynthesize the
+   * element when needed.
    */
-  ElementHandle(Element element) {
-    _context = element.context;
-    _location = element.location;
-    _elementReference = new WeakReference<Element>(element);
-  }
+  ElementHandle(this._resynthesizer, this._location);
 
   /**
-   * Return the element being represented by this handle, reconstituting the element if the
-   * reference has been set to `null`.
-   *
-   * @return the element being represented by this handle
+   * Return the element being represented by this handle, reconstituting the
+   * element if the reference has been set to `null`.
    */
   Element get actualElement {
-    Element element = _elementReference.get();
-    if (element == null) {
-      element = _context.getElement(_location);
-      _elementReference = new WeakReference<Element>(element);
+    if (_elementReference == null) {
+      _elementReference = _resynthesizer.getElement(_location);
     }
-    return element;
+    return _elementReference;
   }
 
   @override
-  AnalysisContext get context => _context;
+  AnalysisContext get context => _resynthesizer.context;
 
   @override
   String get displayName => actualElement.displayName;
 
   @override
-  SourceRange get docRange => actualElement.docRange;
+  String get documentationComment => actualElement.documentationComment;
 
   @override
   Element get enclosingElement => actualElement.enclosingElement;
 
   @override
   int get hashCode => _location.hashCode;
 
   @override
   bool get isDeprecated => actualElement.isDeprecated;
 
   @override
+  bool get isFactory => actualElement.isFactory;
+
+  @override
+  bool get isJS => actualElement.isJS;
+
+  @override
   bool get isOverride => actualElement.isOverride;
 
   @override
   bool get isPrivate => actualElement.isPrivate;
 
   @override
+  bool get isProtected => actualElement.isProtected;
+
+  @override
   bool get isPublic => actualElement.isPublic;
 
   @override
+  bool get isRequired => actualElement.isRequired;
+
+  @override
   bool get isSynthetic => actualElement.isSynthetic;
 
   @override
   LibraryElement get library =>
       getAncestor((element) => element is LibraryElement);
 
   @override
+  Source get librarySource => actualElement.librarySource;
+
+  @override
   ElementLocation get location => _location;
 
   @override
   List<ElementAnnotation> get metadata => actualElement.metadata;
 
   @override
   String get name => actualElement.name;
 
   @override
   int get nameLength => actualElement.nameLength;
 
   @override
   int get nameOffset => actualElement.nameOffset;
 
-  @deprecated
-  @override
-  AstNode get node => computeNode();
-
   @override
   Source get source => actualElement.source;
 
   @override
   CompilationUnit get unit => actualElement.unit;
 
   @override
   bool operator ==(Object object) =>
       object is Element && object.location == _location;
 
   @override
   accept(ElementVisitor visitor) => actualElement.accept(visitor);
 
   @override
-  String computeDocumentationComment() =>
-      actualElement.computeDocumentationComment();
+  String computeDocumentationComment() => documentationComment;
 
   @override
   AstNode computeNode() => actualElement.computeNode();
 
   @override
-  Element getAncestor(Predicate<Element> predicate) =>
+  Element/*=E*/ getAncestor/*<E extends Element >*/(
+          Predicate<Element> predicate) =>
       actualElement.getAncestor(predicate);
 
   @override
   String getExtendedDisplayName(String shortName) =>
       actualElement.getExtendedDisplayName(shortName);
 
   @override
   bool isAccessibleIn(LibraryElement library) =>
       actualElement.isAccessibleIn(library);
 
   @override
+  String toString() => actualElement.toString();
+
+  @override
   void visitChildren(ElementVisitor visitor) {
     actualElement.visitChildren(visitor);
   }
-
-  /**
-   * Return a handle on the given element. If the element is already a handle, then it will be
-   * returned directly, otherwise a handle of the appropriate class will be constructed.
-   *
-   * @param element the element for which a handle is to be constructed
-   * @return a handle on the given element
-   */
-  static Element forElement(Element element) {
-    if (element is ElementHandle) {
-      return element;
-    }
-    while (true) {
-      if (element.kind == ElementKind.CLASS) {
-        return new ClassElementHandle(element as ClassElement);
-      } else if (element.kind == ElementKind.COMPILATION_UNIT) {
-        return new CompilationUnitElementHandle(
-            element as CompilationUnitElement);
-      } else if (element.kind == ElementKind.CONSTRUCTOR) {
-        return new ConstructorElementHandle(element as ConstructorElement);
-      } else if (element.kind == ElementKind.EXPORT) {
-        return new ExportElementHandle(element as ExportElement);
-      } else if (element.kind == ElementKind.FIELD) {
-        return new FieldElementHandle(element as FieldElement);
-      } else if (element.kind == ElementKind.FUNCTION) {
-        return new FunctionElementHandle(element as FunctionElement);
-      } else if (element.kind == ElementKind.GETTER) {
-        return new PropertyAccessorElementHandle(
-            element as PropertyAccessorElement);
-      } else if (element.kind == ElementKind.IMPORT) {
-        return new ImportElementHandle(element as ImportElement);
-      } else if (element.kind == ElementKind.LABEL) {
-        return new LabelElementHandle(element as LabelElement);
-      } else if (element.kind == ElementKind.LIBRARY) {
-        return new LibraryElementHandle(element as LibraryElement);
-      } else if (element.kind == ElementKind.LOCAL_VARIABLE) {
-        return new LocalVariableElementHandle(element as LocalVariableElement);
-      } else if (element.kind == ElementKind.METHOD) {
-        return new MethodElementHandle(element as MethodElement);
-      } else if (element.kind == ElementKind.PARAMETER) {
-        return new ParameterElementHandle(element as ParameterElement);
-      } else if (element.kind == ElementKind.PREFIX) {
-        return new PrefixElementHandle(element as PrefixElement);
-      } else if (element.kind == ElementKind.SETTER) {
-        return new PropertyAccessorElementHandle(
-            element as PropertyAccessorElement);
-      } else if (element.kind == ElementKind.TOP_LEVEL_VARIABLE) {
-        return new TopLevelVariableElementHandle(
-            element as TopLevelVariableElement);
-      } else if (element.kind == ElementKind.FUNCTION_TYPE_ALIAS) {
-        return new FunctionTypeAliasElementHandle(
-            element as FunctionTypeAliasElement);
-      } else if (element.kind == ElementKind.TYPE_PARAMETER) {
-        return new TypeParameterElementHandle(element as TypeParameterElement);
-      } else {
-        throw new UnsupportedOperationException();
-      }
-      break;
-    }
-  }
-
-  /**
-   * Return an array of the same size as the given array where each element of the returned array is
-   * a handle for the corresponding element of the given array.
-   *
-   * @param elements the elements for which handles are to be created
-   * @return an array of handles to the given elements
-   */
-  static List<Element> forElements(List<Element> elements) {
-    int length = elements.length;
-    List<Element> handles = new List<Element>.from(elements);
-    for (int i = 0; i < length; i++) {
-      handles[i] = forElement(elements[i]);
-    }
-    return handles;
-  }
 }
 
 /**
- * The abstract class `ExecutableElementHandle` implements the behavior common to objects that
- * implement a handle to an [ExecutableElement].
+ * Interface which allows an [Element] handle to be resynthesized based on an
+ * [ElementLocation].  The concrete classes implementing element handles use
+ * this interface to retrieve the underlying elements when queried.
+ */
+abstract class ElementResynthesizer {
+  /**
+   * The context that owns the element to be resynthesized.
+   */
+  final AnalysisContext context;
+
+  /**
+   * Initialize a newly created resynthesizer to resynthesize elements in the
+   * given [context].
+   */
+  ElementResynthesizer(this.context);
+
+  /**
+   * Return the element referenced by the given [location].
+   */
+  Element getElement(ElementLocation location);
+}
+
+/**
+ * A handle to an [ExecutableElement].
  */
 abstract class ExecutableElementHandle extends ElementHandle
     implements ExecutableElement {
   /**
-   * Initialize a newly created element handle to represent the given element.
-   *
-   * @param element the element being represented
+   * Initialize a newly created element handle to represent the element at the
+   * given [_location]. The [_resynthesizer] will be used to resynthesize the
+   * element when needed.
    */
-  ExecutableElementHandle(ExecutableElement element) : super(element);
+  ExecutableElementHandle(
+      ElementResynthesizer resynthesizer, ElementLocation location)
+      : super(resynthesizer, location);
 
   @override
   ExecutableElement get actualElement =>
       super.actualElement as ExecutableElement;
 
   @override
   List<FunctionElement> get functions => actualElement.functions;
 
   @override
   bool get hasImplicitReturnType => actualElement.hasImplicitReturnType;
@@ skipping 32 matching lines @@
   DartType get returnType => actualElement.returnType;
 
   @override
   FunctionType get type => actualElement.type;
 
   @override
   List<TypeParameterElement> get typeParameters => actualElement.typeParameters;
 }
 
 /**
- * Instances of the class `ExportElementHandle` implement a handle to an `ExportElement`
- * .
+ * A handle to an [ExportElement].
  */
 class ExportElementHandle extends ElementHandle implements ExportElement {
   /**
-   * Initialize a newly created element handle to represent the given element.
-   *
-   * @param element the element being represented
+   * Initialize a newly created element handle to represent the element at the
+   * given [_location]. The [_resynthesizer] will be used to resynthesize the
+   * element when needed.
    */
-  ExportElementHandle(ExportElement element) : super(element);
+  ExportElementHandle(
+      ElementResynthesizer resynthesizer, ElementLocation location)
+      : super(resynthesizer, location);
 
   @override
   ExportElement get actualElement => super.actualElement as ExportElement;
 
   @override
   List<NamespaceCombinator> get combinators => actualElement.combinators;
 
   @override
   LibraryElement get exportedLibrary => actualElement.exportedLibrary;
 
   @override
   ElementKind get kind => ElementKind.EXPORT;
 
   @override
   String get uri => actualElement.uri;
 
   @override
   int get uriEnd => actualElement.uriEnd;
 
   @override
   int get uriOffset => actualElement.uriOffset;
 }
 
 /**
- * Instances of the class `FieldElementHandle` implement a handle to a `FieldElement`.
+ * A handle to a [FieldElement].
  */
 class FieldElementHandle extends PropertyInducingElementHandle
     implements FieldElement {
   /**
-   * Initialize a newly created element handle to represent the given element.
-   *
-   * @param element the element being represented
+   * Initialize a newly created element handle to represent the element at the
+   * given [_location]. The [_resynthesizer] will be used to resynthesize the
+   * element when needed.
    */
-  FieldElementHandle(FieldElement element) : super(element);
+  FieldElementHandle(
+      ElementResynthesizer resynthesizer, ElementLocation location)
+      : super(resynthesizer, location);
 
   @override
   FieldElement get actualElement => super.actualElement as FieldElement;
 
   @override
   ClassElement get enclosingElement => actualElement.enclosingElement;
 
   @override
   bool get isEnumConstant => actualElement.isEnumConstant;
 
   @override
+  bool get isVirtual => actualElement.isVirtual;
+
+  @override
   ElementKind get kind => ElementKind.FIELD;
 
   @override
   VariableDeclaration computeNode() => actualElement.computeNode();
 }
 
 /**
- * Instances of the class `FunctionElementHandle` implement a handle to a
- * `FunctionElement`.
+ * A handle to a [FunctionElement].
  */
 class FunctionElementHandle extends ExecutableElementHandle
     implements FunctionElement {
   /**
-   * Initialize a newly created element handle to represent the given element.
-   *
-   * @param element the element being represented
+   * Initialize a newly created element handle to represent the element at the
+   * given [_location]. The [_resynthesizer] will be used to resynthesize the
+   * element when needed.
    */
-  FunctionElementHandle(FunctionElement element) : super(element);
+  FunctionElementHandle(
+      ElementResynthesizer resynthesizer, ElementLocation location)
+      : super(resynthesizer, location);
 
   @override
   FunctionElement get actualElement => super.actualElement as FunctionElement;
 
   @override
   bool get isEntryPoint => actualElement.isEntryPoint;
 
   @override
   ElementKind get kind => ElementKind.FUNCTION;
 
   @override
   SourceRange get visibleRange => actualElement.visibleRange;
 
   @override
   FunctionDeclaration computeNode() => actualElement.computeNode();
 }
 
 /**
- * Instances of the class `FunctionTypeAliasElementHandle` implement a handle to a
- * `FunctionTypeAliasElement`.
+ * A handle to a [FunctionTypeAliasElement].
  */
 class FunctionTypeAliasElementHandle extends ElementHandle
     implements FunctionTypeAliasElement {
   /**
-   * Initialize a newly created element handle to represent the given element.
-   *
-   * @param element the element being represented
+   * Initialize a newly created element handle to represent the element at the
+   * given [_location]. The [_resynthesizer] will be used to resynthesize the
+   * element when needed.
    */
-  FunctionTypeAliasElementHandle(FunctionTypeAliasElement element)
-      : super(element);
+  FunctionTypeAliasElementHandle(
+      ElementResynthesizer resynthesizer, ElementLocation location)
+      : super(resynthesizer, location);
 
   @override
   FunctionTypeAliasElement get actualElement =>
       super.actualElement as FunctionTypeAliasElement;
 
   @override
   CompilationUnitElement get enclosingElement =>
       super.enclosingElement as CompilationUnitElement;
 
   @override
   ElementKind get kind => ElementKind.FUNCTION_TYPE_ALIAS;
 
   @override
   List<ParameterElement> get parameters => actualElement.parameters;
 
   @override
   DartType get returnType => actualElement.returnType;
 
   @override
   FunctionType get type => actualElement.type;
 
   @override
   List<TypeParameterElement> get typeParameters => actualElement.typeParameters;
 
   @override
   FunctionTypeAlias computeNode() => actualElement.computeNode();
 }
 
 /**
- * Instances of the class `ImportElementHandle` implement a handle to an `ImportElement`
- * .
+ * A handle to an [ImportElement].
  */
 class ImportElementHandle extends ElementHandle implements ImportElement {
   /**
-   * Initialize a newly created element handle to represent the given element.
-   *
-   * @param element the element being represented
+   * Initialize a newly created element handle to represent the element at the
+   * given [_location]. The [_resynthesizer] will be used to resynthesize the
+   * element when needed.
    */
-  ImportElementHandle(ImportElement element) : super(element);
+  ImportElementHandle(
+      ElementResynthesizer resynthesizer, ElementLocation location)
+      : super(resynthesizer, location);
 
   @override
   ImportElement get actualElement => super.actualElement as ImportElement;
 
   @override
   List<NamespaceCombinator> get combinators => actualElement.combinators;
 
   @override
   LibraryElement get importedLibrary => actualElement.importedLibrary;
 
@@ skipping 13 matching lines @@
   String get uri => actualElement.uri;
 
   @override
   int get uriEnd => actualElement.uriEnd;
 
   @override
   int get uriOffset => actualElement.uriOffset;
 }
 
 /**
- * Instances of the class `LabelElementHandle` implement a handle to a `LabelElement`.
+ * A handle to a [LabelElement].
  */
 class LabelElementHandle extends ElementHandle implements LabelElement {
   /**
-   * Initialize a newly created element handle to represent the given element.
-   *
-   * @param element the element being represented
+   * Initialize a newly created element handle to represent the element at the
+   * given [_location]. The [_resynthesizer] will be used to resynthesize the
+   * element when needed.
    */
-  LabelElementHandle(LabelElement element) : super(element);
+  LabelElementHandle(
+      ElementResynthesizer resynthesizer, ElementLocation location)
+      : super(resynthesizer, location);
 
   @override
   ExecutableElement get enclosingElement =>
       super.enclosingElement as ExecutableElement;
 
   @override
   ElementKind get kind => ElementKind.LABEL;
 }
 
 /**
- * Instances of the class `LibraryElementHandle` implement a handle to a
- * `LibraryElement`.
+ * A handle to a [LibraryElement].
  */
 class LibraryElementHandle extends ElementHandle implements LibraryElement {
   /**
-   * Initialize a newly created element handle to represent the given element.
-   *
-   * @param element the element being represented
+   * Initialize a newly created element handle to represent the element at the
+   * given [_location]. The [_resynthesizer] will be used to resynthesize the
+   * element when needed.
    */
-  LibraryElementHandle(LibraryElement element) : super(element);
+  LibraryElementHandle(
+      ElementResynthesizer resynthesizer, ElementLocation location)
+      : super(resynthesizer, location);
 
   @override
   LibraryElement get actualElement => super.actualElement as LibraryElement;
 
   @override
   CompilationUnitElement get definingCompilationUnit =>
       actualElement.definingCompilationUnit;
 
   @override
   FunctionElement get entryPoint => actualElement.entryPoint;
 
   @override
   List<LibraryElement> get exportedLibraries => actualElement.exportedLibraries;
 
   @override
   Namespace get exportNamespace => actualElement.exportNamespace;
 
   @override
   List<ExportElement> get exports => actualElement.exports;
 
   @override
   bool get hasExtUri => actualElement.hasExtUri;
 
   @override
   bool get hasLoadLibraryFunction => actualElement.hasLoadLibraryFunction;
 
   @override
+  String get identifier => location.components.last;
+
+  @override
   List<LibraryElement> get importedLibraries => actualElement.importedLibraries;
 
   @override
   List<ImportElement> get imports => actualElement.imports;
 
   @override
   bool get isBrowserApplication => actualElement.isBrowserApplication;
 
   @override
+  bool get isDartAsync => actualElement.isDartAsync;
+
+  @override
   bool get isDartCore => actualElement.isDartCore;
 
   @override
   bool get isInSdk => actualElement.isInSdk;
 
   @override
   ElementKind get kind => ElementKind.LIBRARY;
 
   @override
+  List<LibraryElement> get libraryCycle => actualElement.libraryCycle;
+
+  @override
   FunctionElement get loadLibraryFunction => actualElement.loadLibraryFunction;
 
   @override
   List<CompilationUnitElement> get parts => actualElement.parts;
 
   @override
   List<PrefixElement> get prefixes => actualElement.prefixes;
 
   @override
   Namespace get publicNamespace => actualElement.publicNamespace;
 
   @override
   List<CompilationUnitElement> get units => actualElement.units;
 
   @override
-  List<LibraryElement> get visibleLibraries => actualElement.visibleLibraries;
-
-  @override
   List<ImportElement> getImportsWithPrefix(PrefixElement prefixElement) =>
       actualElement.getImportsWithPrefix(prefixElement);
 
   @override
   ClassElement getType(String className) => actualElement.getType(className);
-
-  @override
-  bool isUpToDate(int timeStamp) => actualElement.isUpToDate(timeStamp);
 }
 
 /**
- * Instances of the class `LocalVariableElementHandle` implement a handle to a
- * `LocalVariableElement`.
+ * A handle to a [LocalVariableElement].
  */
 class LocalVariableElementHandle extends VariableElementHandle
     implements LocalVariableElement {
   /**
-   * Initialize a newly created element handle to represent the given element.
-   *
-   * @param element the element being represented
+   * Initialize a newly created element handle to represent the element at the
+   * given [_location]. The [_resynthesizer] will be used to resynthesize the
+   * element when needed.
    */
-  LocalVariableElementHandle(LocalVariableElement element) : super(element);
+  LocalVariableElementHandle(
+      ElementResynthesizer resynthesizer, ElementLocation location)
+      : super(resynthesizer, location);
 
   @override
   LocalVariableElement get actualElement =>
       super.actualElement as LocalVariableElement;
 
   @override
   ElementKind get kind => ElementKind.LOCAL_VARIABLE;
 
   @override
   SourceRange get visibleRange => actualElement.visibleRange;
 
   @override
   VariableDeclaration computeNode() => actualElement.computeNode();
 }
 
 /**
- * Instances of the class `MethodElementHandle` implement a handle to a `MethodElement`.
+ * A handle to a [MethodElement].
  */
 class MethodElementHandle extends ExecutableElementHandle
     implements MethodElement {
   /**
-   * Initialize a newly created element handle to represent the given element.
-   *
-   * @param element the element being represented
+   * Initialize a newly created element handle to represent the element at the
+   * given [_location]. The [_resynthesizer] will be used to resynthesize the
+   * element when needed.
    */
-  MethodElementHandle(MethodElement element) : super(element);
+  MethodElementHandle(
+      ElementResynthesizer resynthesizer, ElementLocation location)
+      : super(resynthesizer, location);
 
   @override
   MethodElement get actualElement => super.actualElement as MethodElement;
 
   @override
   ClassElement get enclosingElement => super.enclosingElement as ClassElement;
 
   @override
   bool get isStatic => actualElement.isStatic;
 
   @override
   ElementKind get kind => ElementKind.METHOD;
 
   @override
   MethodDeclaration computeNode() => actualElement.computeNode();
 }
 
 /**
- * Instances of the class `ParameterElementHandle` implement a handle to a
- * `ParameterElement`.
+ * A handle to a [ParameterElement].
  */
 class ParameterElementHandle extends VariableElementHandle
     with ParameterElementMixin
     implements ParameterElement {
   /**
-   * Initialize a newly created element handle to represent the given element.
-   *
-   * @param element the element being represented
+   * Initialize a newly created element handle to represent the element at the
+   * given [_location]. The [_resynthesizer] will be used to resynthesize the
+   * element when needed.
    */
-  ParameterElementHandle(ParameterElement element) : super(element);
+  ParameterElementHandle(
+      ElementResynthesizer resynthesizer, ElementLocation location)
+      : super(resynthesizer, location);
 
   @override
   ParameterElement get actualElement => super.actualElement as ParameterElement;
 
   @override
   String get defaultValueCode => actualElement.defaultValueCode;
 
   @override
+  bool get isCovariant => actualElement.isCovariant;
+
+  @override
   bool get isInitializingFormal => actualElement.isInitializingFormal;
 
   @override
   ElementKind get kind => ElementKind.PARAMETER;
 
   @override
   ParameterKind get parameterKind => actualElement.parameterKind;
 
   @override
   List<ParameterElement> get parameters => actualElement.parameters;
 
   @override
   List<TypeParameterElement> get typeParameters => actualElement.typeParameters;
 
   @override
   SourceRange get visibleRange => actualElement.visibleRange;
+
+  @override
+  FormalParameter computeNode() => super.computeNode();
 }
 
 /**
- * Instances of the class `PrefixElementHandle` implement a handle to a `PrefixElement`.
+ * A handle to a [PrefixElement].
  */
 class PrefixElementHandle extends ElementHandle implements PrefixElement {
   /**
-   * Initialize a newly created element handle to represent the given element.
-   *
-   * @param element the element being represented
+   * Initialize a newly created element handle to represent the element at the
+   * given [_location]. The [_resynthesizer] will be used to resynthesize the
+   * element when needed.
    */
-  PrefixElementHandle(PrefixElement element) : super(element);
+  PrefixElementHandle(
+      ElementResynthesizer resynthesizer, ElementLocation location)
+      : super(resynthesizer, location);
 
   @override
   PrefixElement get actualElement => super.actualElement as PrefixElement;
 
   @override
   LibraryElement get enclosingElement =>
       super.enclosingElement as LibraryElement;
 
   @override
-  List<LibraryElement> get importedLibraries => actualElement.importedLibraries;
+  List<LibraryElement> get importedLibraries => LibraryElement.EMPTY_LIST;
 
   @override
   ElementKind get kind => ElementKind.PREFIX;
 }
 
 /**
- * Instances of the class `PropertyAccessorElementHandle` implement a handle to a
- * `PropertyAccessorElement`.
+ * A handle to a [PropertyAccessorElement].
  */
 class PropertyAccessorElementHandle extends ExecutableElementHandle
     implements PropertyAccessorElement {
   /**
-   * Initialize a newly created element handle to represent the given element.
-   *
-   * @param element the element being represented
+   * Initialize a newly created element handle to represent the element at the
+   * given [_location]. The [_resynthesizer] will be used to resynthesize the
+   * element when needed.
    */
-  PropertyAccessorElementHandle(PropertyAccessorElement element)
-      : super(element);
+  PropertyAccessorElementHandle(
+      ElementResynthesizer resynthesizer, ElementLocation location)
+      : super(resynthesizer, location);
 
   @override
   PropertyAccessorElement get actualElement =>
       super.actualElement as PropertyAccessorElement;
 
   @override
   PropertyAccessorElement get correspondingGetter =>
       actualElement.correspondingGetter;
 
   @override
   PropertyAccessorElement get correspondingSetter =>
       actualElement.correspondingSetter;
 
   @override
-  bool get isGetter => actualElement.isGetter;
+  bool get isGetter => !isSetter;
 
   @override
-  bool get isSetter => actualElement.isSetter;
+  bool get isSetter => location.components.last.endsWith('=');
 
   @override
   ElementKind get kind {
     if (isGetter) {
       return ElementKind.GETTER;
     } else {
       return ElementKind.SETTER;
     }
   }
 
   @override
   PropertyInducingElement get variable => actualElement.variable;
 }
 
 /**
- * The abstract class `PropertyInducingElementHandle` implements the behavior common to
- * objects that implement a handle to an `PropertyInducingElement`.
+ * A handle to an [PropertyInducingElement].
  */
 abstract class PropertyInducingElementHandle extends VariableElementHandle
     implements PropertyInducingElement {
   /**
-   * Initialize a newly created element handle to represent the given element.
-   *
-   * @param element the element being represented
+   * Initialize a newly created element handle to represent the element at the
+   * given [_location]. The [_resynthesizer] will be used to resynthesize the
+   * element when needed.
    */
-  PropertyInducingElementHandle(PropertyInducingElement element)
-      : super(element);
+  PropertyInducingElementHandle(
+      ElementResynthesizer resynthesizer, ElementLocation location)
+      : super(resynthesizer, location);
 
   @override
   PropertyInducingElement get actualElement =>
       super.actualElement as PropertyInducingElement;
 
   @override
   PropertyAccessorElement get getter => actualElement.getter;
 
   @override
   DartType get propagatedType => actualElement.propagatedType;
 
   @override
   PropertyAccessorElement get setter => actualElement.setter;
 }
 
 /**
- * Instances of the class `TopLevelVariableElementHandle` implement a handle to a
- * `TopLevelVariableElement`.
+ * A handle to a [TopLevelVariableElement].
  */
 class TopLevelVariableElementHandle extends PropertyInducingElementHandle
     implements TopLevelVariableElement {
   /**
-   * Initialize a newly created element handle to represent the given element.
-   *
-   * @param element the element being represented
+   * Initialize a newly created element handle to represent the element at the
+   * given [_location]. The [_resynthesizer] will be used to resynthesize the
+   * element when needed.
    */
-  TopLevelVariableElementHandle(TopLevelVariableElement element)
-      : super(element);
+  TopLevelVariableElementHandle(
+      ElementResynthesizer resynthesizer, ElementLocation location)
+      : super(resynthesizer, location);
 
   @override
   ElementKind get kind => ElementKind.TOP_LEVEL_VARIABLE;
+
+  @override
+  VariableDeclaration computeNode() => super.computeNode();
 }
 
 /**
- * Instances of the class `TypeParameterElementHandle` implement a handle to a
- * [TypeParameterElement].
+ * A handle to a [TypeParameterElement].
  */
 class TypeParameterElementHandle extends ElementHandle
     implements TypeParameterElement {
   /**
-   * Initialize a newly created element handle to represent the given element.
-   *
-   * @param element the element being represented
+   * Initialize a newly created element handle to represent the element at the
+   * given [_location]. The [_resynthesizer] will be used to resynthesize the
+   * element when needed.
    */
-  TypeParameterElementHandle(TypeParameterElement element) : super(element);
+  TypeParameterElementHandle(
+      ElementResynthesizer resynthesizer, ElementLocation location)
+      : super(resynthesizer, location);
 
   @override
   TypeParameterElement get actualElement =>
       super.actualElement as TypeParameterElement;
 
   @override
   DartType get bound => actualElement.bound;
 
   @override
   ElementKind get kind => ElementKind.TYPE_PARAMETER;
 
   @override
   TypeParameterType get type => actualElement.type;
 }
 
 /**
- * The abstract class `VariableElementHandle` implements the behavior common to objects that
- * implement a handle to an `VariableElement`.
+ * A handle to an [VariableElement].
  */
 abstract class VariableElementHandle extends ElementHandle
     implements VariableElement {
   /**
-   * Initialize a newly created element handle to represent the given element.
-   *
-   * @param element the element being represented
+   * Initialize a newly created element handle to represent the element at the
+   * given [_location]. The [_resynthesizer] will be used to resynthesize the
+   * element when needed.
    */
-  VariableElementHandle(VariableElement element) : super(element);
+  VariableElementHandle(
+      ElementResynthesizer resynthesizer, ElementLocation location)
+      : super(resynthesizer, location);
 
   @override
   VariableElement get actualElement => super.actualElement as VariableElement;
 
   @override
   DartObject get constantValue => actualElement.constantValue;
 
   @override
   bool get hasImplicitType => actualElement.hasImplicitType;
 
   @override
   FunctionElement get initializer => actualElement.initializer;
 
   @override
   bool get isConst => actualElement.isConst;
 
   @override
   bool get isFinal => actualElement.isFinal;
 
+  @deprecated
   @override
   bool get isPotentiallyMutatedInClosure =>
       actualElement.isPotentiallyMutatedInClosure;
 
+  @deprecated
   @override
   bool get isPotentiallyMutatedInScope =>
       actualElement.isPotentiallyMutatedInScope;
 
   @override
   bool get isStatic => actualElement.isStatic;
 
   @override
   DartType get type => actualElement.type;
+
+  @override
+  DartObject computeConstantValue() => actualElement.computeConstantValue();
 }
-
-/**
- * TODO(scheglov) invalid implementation
- */
-class WeakReference<T> {
-  final T value;
-  WeakReference(this.value);
-  T get() => value;
-}