Implement TypeParameterElementForLink.location.

pkg/analyzer/lib/src/summary/link.dart

 // Copyright (c) 2016, 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.
 
 /**
  * This library is capable of producing linked summaries from unlinked
  * ones (or prelinked ones).  It functions by building a miniature
  * element model to represent the contents of the summaries, and then
  * scanning the element model to gather linked information and adding
  * it to the summary data structures.
@@ skipping 401 matching lines @@
     if (_fields == null) {
       _fields = <FieldElementForLink_ClassField>[];
       for (UnlinkedVariable field in _unlinkedClass.fields) {
         _fields.add(new FieldElementForLink_ClassField(this, field));
       }
     }
     return _fields;
   }
 
   @override
+  String get identifier => name;
+
+  @override
   List<InterfaceType> get interfaces => _interfaces ??=
       _unlinkedClass.interfaces.map(_computeInterfaceType).toList();
 
   @override
   bool get isObject => _unlinkedClass.hasNoSupertype;
 
   @override
   LibraryElementForLink get library => enclosingElement.library;
 
   @override
@@ skipping 200 matching lines @@
   void link(CompilationUnitElementInBuildUnit compilationUnit) {}
 
   @override
   String toString() => '$enclosingElement.$name';
 }
 
 /**
  * Element representing a compilation unit resynthesized from a
  * summary during linking.
  */
-abstract class CompilationUnitElementForLink implements CompilationUnitElement {
+abstract class CompilationUnitElementForLink
+    implements CompilationUnitElementImpl {
   /**
    * The unlinked representation of the compilation unit in the
    * summary.
    */
   final UnlinkedUnit _unlinkedUnit;
 
   /**
    * For each entry in [UnlinkedUnit.references], the element referred
    * to by the reference, or `null` if it hasn't been located yet.
    */
   final List<ReferenceableElementForLink> _references;
 
+  /**
+   * The absolute URI of this compilation unit.
+   */
+  final String _absoluteUri;
+
   List<ClassElementForLink_Class> _types;
   Map<String, ReferenceableElementForLink> _containedNames;
   List<TopLevelVariableElementForLink> _topLevelVariables;
   List<ClassElementForLink_Enum> _enums;
 
   /**
    * Index of this unit in the list of units in the enclosing library.
    */
   final int unitNum;
 
-  CompilationUnitElementForLink(
-      UnlinkedUnit unlinkedUnit, this.unitNum, int numReferences)
+  CompilationUnitElementForLink(UnlinkedUnit unlinkedUnit, this.unitNum,
+      int numReferences, this._absoluteUri)
       : _references = new List<ReferenceableElementForLink>(numReferences),
         _unlinkedUnit = unlinkedUnit;
 
   @override
   LibraryElementForLink get enclosingElement;
 
   @override
   List<ClassElementForLink_Enum> get enums {
     if (_enums == null) {
       _enums = <ClassElementForLink_Enum>[];
       for (UnlinkedEnum unlinkedEnum in _unlinkedUnit.enums) {
         _enums.add(new ClassElementForLink_Enum(this, unlinkedEnum));
       }
     }
     return _enums;
   }
 
+  @override
+  String get identifier => _absoluteUri;
+
   /**
    * Indicates whether this compilation element is part of the build unit
    * currently being linked.
    */
   bool get isInBuildUnit;
 
   /**
    * Determine whether type inference is complete in this compilation unit.
    */
   bool get isTypeInferenceComplete {
@@ skipping 161 matching lines @@
  * Element representing a compilation unit which is part of the build
  * unit being linked.
  */
 class CompilationUnitElementInBuildUnit extends CompilationUnitElementForLink {
   @override
   final LinkedUnitBuilder _linkedUnit;
 
   @override
   final LibraryElementInBuildUnit enclosingElement;
 
-  CompilationUnitElementInBuildUnit(this.enclosingElement,
-      UnlinkedUnit unlinkedUnit, this._linkedUnit, int unitNum)
-      : super(unlinkedUnit, unitNum, unlinkedUnit.references.length);
+  CompilationUnitElementInBuildUnit(
+      this.enclosingElement,
+      UnlinkedUnit unlinkedUnit,
+      this._linkedUnit,
+      int unitNum,
+      String absoluteUri)
+      : super(
+            unlinkedUnit, unitNum, unlinkedUnit.references.length, absoluteUri);
 
   @override
   bool get isInBuildUnit => true;
 
   @override
   LibraryElementInBuildUnit get library => enclosingElement;
 
   /**
    * If this compilation unit already has a reference in its references table
    * matching [dependency], [name], [numTypeParameters], [unitNum],
@@ skipping 143 matching lines @@
  */
 class CompilationUnitElementInDependency extends CompilationUnitElementForLink {
   @override
   final LinkedUnit _linkedUnit;
 
   List<EntityRef> _linkedTypeRefs;
 
   @override
   final LibraryElementInDependency enclosingElement;
 
-  CompilationUnitElementInDependency(this.enclosingElement,
-      UnlinkedUnit unlinkedUnit, LinkedUnit linkedUnit, int unitNum)
+  CompilationUnitElementInDependency(
+      this.enclosingElement,
+      UnlinkedUnit unlinkedUnit,
+      LinkedUnit linkedUnit,
+      int unitNum,
+      String absoluteUri)
       : _linkedUnit = linkedUnit,
-        super(unlinkedUnit, unitNum, linkedUnit.references.length) {
+        super(
+            unlinkedUnit, unitNum, linkedUnit.references.length, absoluteUri) {
     // Make one pass through the linked types to determine the lengths for
     // _linkedTypeRefs and _linkedTypes.  TODO(paulberry): add an int to the
     // summary to make this unnecessary.
     int maxLinkedTypeSlot = 0;
     for (EntityRef ref in _linkedUnit.types) {
       if (ref.slot > maxLinkedTypeSlot) {
         maxLinkedTypeSlot = ref.slot;
       }
     }
     // Initialize _linkedTypeRefs.
@@ skipping 1554 matching lines @@
   }
 }
 
 /**
  * Element representing a library resynthesied from a summary during
  * linking.  The type parameter, [UnitElement], represents the type
  * that will be used for the compilation unit elements.
  */
 abstract class LibraryElementForLink<
         UnitElement extends CompilationUnitElementForLink>
-    implements LibraryElement {
+    implements LibraryElementImpl {
   /**
    * Pointer back to the linker.
    */
   final Linker _linker;
 
   /**
    * The absolute URI of this library.
    */
   final Uri _absoluteUri;
 
@@ skipping 18 matching lines @@
       _definingUnlinkedUnit ??= _linker.getUnit(_absoluteUri.toString());
 
   @override
   Element get enclosingElement => null;
 
   @override
   List<LibraryElementForLink> get exportedLibraries => _exportedLibraries ??=
       _linkedLibrary.exportDependencies.map(_getDependency).toList();
 
   @override
+  String get identifier => _absoluteUri.toString();
+
+  @override
   List<LibraryElementForLink> get importedLibraries => _importedLibraries ??=
       _linkedLibrary.importDependencies.map(_getDependency).toList();
 
   /**
    * If this library is part of the build unit being linked, return the library
    * cycle it is part of.  Otherwise return `null`.
    */
   LibraryCycleForLink get libraryCycleForLink;
 
   @override
   List<UnitElement> get units {
     if (_units == null) {
       UnlinkedUnit definingUnit = definingUnlinkedUnit;
-      _units = <UnitElement>[_makeUnitElement(definingUnit, 0)];
+      _units = <UnitElement>[
+        _makeUnitElement(definingUnit, 0, _absoluteUri.toString())
+      ];
       int numParts = definingUnit.parts.length;
       for (int i = 0; i < numParts; i++) {
         // TODO(paulberry): make sure we handle the case where Uri.parse fails.
         // TODO(paulberry): make sure we handle the case where
         // resolveRelativeUri fails.
-        UnlinkedUnit partUnit = _linker.getUnit(resolveRelativeUri(
+        String partAbsoluteUri = resolveRelativeUri(
                 _absoluteUri, Uri.parse(definingUnit.publicNamespace.parts[i]))
-            .toString());
-        _units.add(
-            _makeUnitElement(partUnit ?? new UnlinkedUnitBuilder(), i + 1));
+            .toString();
+        UnlinkedUnit partUnit = _linker.getUnit(partAbsoluteUri);
+        _units.add(_makeUnitElement(
+            partUnit ?? new UnlinkedUnitBuilder(), i + 1, partAbsoluteUri));
       }
     }
     return _units;
   }
 
   /**
    * The linked representation of the library in the summary.
    */
   LinkedLibrary get _linkedLibrary;
 
@@ skipping 24 matching lines @@
    */
   LibraryElementForLink _getDependency(int index) {
     return _dependencies[index] ??= _linker.getLibrary(resolveRelativeUri(
         _absoluteUri, Uri.parse(_linkedLibrary.dependencies[index].uri)));
   }
 
   /**
    * Create a [UnitElement] for one of the library's compilation
    * units.
    */
-  UnitElement _makeUnitElement(UnlinkedUnit unlinkedUnit, int i);
+  UnitElement _makeUnitElement(
+      UnlinkedUnit unlinkedUnit, int i, String absoluteUri);
 }
 
 /**
  * Element representing a library which is part of the build unit
  * being linked.
  */
 class LibraryElementInBuildUnit
     extends LibraryElementForLink<CompilationUnitElementInBuildUnit> {
   @override
   final LinkedLibraryBuilder _linkedLibrary;
@@ skipping 60 matching lines @@
   void unlink() {
     _linkedLibrary.dependencies.length =
         _linkedLibrary.numPrelinkedDependencies;
     for (CompilationUnitElementInBuildUnit unit in units) {
       unit.unlink();
     }
   }
 
   @override
   CompilationUnitElementInBuildUnit _makeUnitElement(
-          UnlinkedUnit unlinkedUnit, int i) =>
+          UnlinkedUnit unlinkedUnit, int i, String absoluteUri) =>
       new CompilationUnitElementInBuildUnit(
-          this, unlinkedUnit, _linkedLibrary.units[i], i);
+          this, unlinkedUnit, _linkedLibrary.units[i], i, absoluteUri);
 }
 
 /**
  * Element representing a library which is depended upon (either
  * directly or indirectly) by the build unit being linked.
  */
 class LibraryElementInDependency
     extends LibraryElementForLink<CompilationUnitElementInDependency> {
   @override
   final LinkedLibrary _linkedLibrary;
 
   LibraryElementInDependency(
       Linker linker, Uri absoluteUri, this._linkedLibrary)
       : super(linker, absoluteUri);
 
   @override
   LibraryCycleForLink get libraryCycleForLink => null;
 
   @override
   CompilationUnitElementInDependency _makeUnitElement(
-          UnlinkedUnit unlinkedUnit, int i) =>
+          UnlinkedUnit unlinkedUnit, int i, String absoluteUri) =>
       new CompilationUnitElementInDependency(
-          this, unlinkedUnit, _linkedLibrary.units[i], i);
+          this, unlinkedUnit, _linkedLibrary.units[i], i, absoluteUri);
 }
 
 /**
  * Specialization of [Node] used to construct the library dependency graph.
  */
 class LibraryNode extends Node<LibraryNode> {
   /**
    * The library this [Node] represents.
    */
   final LibraryElementInBuildUnit library;
@@ skipping 161 matching lines @@
 /**
  * Element representing a method resynthesized from a summary during linking.
  */
 class MethodElementForLink extends ExecutableElementForLink
     implements MethodElementImpl {
   MethodElementForLink(ClassElementForLink_Class enclosingElement,
       UnlinkedExecutable unlinkedExecutable)
       : super(enclosingElement, unlinkedExecutable);
 
   @override
+  String get identifier => name;
+
+  @override
   ElementKind get kind => ElementKind.METHOD;
 
   @override
   noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
+
+  @override
+  String toString() => '$enclosingElement.$name';
 }
 
 /**
  * Instances of [Node] represent nodes in a dependency graph.  The
  * type parameter, [NodeType], is the derived type (this affords some
  * extra type safety by making it difficult to accidentally construct
  * bridges between unrelated dependency graphs).
  */
 abstract class Node<NodeType> {
   /**
@@ skipping 560 matching lines @@
     } else {
       _inferredType = new ExprTypeComputer(variableElement).compute();
     }
   }
 }
 
 /**
  * Element representing a type parameter resynthesized from a summary during
  * linking.
  */
-class TypeParameterElementForLink implements TypeParameterElement {
+class TypeParameterElementForLink implements TypeParameterElementImpl {
   /**
    * The unlinked representation of the type parameter in the summary.
    */
   final UnlinkedTypeParam _unlinkedTypeParam;
 
   /**
    * The number of type parameters whose scope overlaps this one, and which are
    * declared earlier in the file.
    */
   final int nestingLevel;
 
+  @override
+  final TypeParameterizedElementForLink enclosingElement;
+
   TypeParameterTypeImpl _type;
+  ElementLocation _location;
 
-  TypeParameterElementForLink(this._unlinkedTypeParam, this.nestingLevel);
+  TypeParameterElementForLink(
+      this.enclosingElement, this._unlinkedTypeParam, this.nestingLevel);
 
   @override
   DartType get bound {
     if (_unlinkedTypeParam.bound == null) {
       return null;
     }
     // TODO(scheglov) implement
     throw new UnimplementedError();
   }
 
   @override
+  String get identifier => name;
+
+  @override
   ElementKind get kind => ElementKind.TYPE_PARAMETER;
 
   @override
+  ElementLocation get location =>
+      _location ??= new ElementLocationImpl.con1(this);
+
+  @override
   String get name => _unlinkedTypeParam.name;
 
   @override
   TypeParameterTypeImpl get type => _type ??= new TypeParameterTypeImpl(this);
 
   @override
   noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
 }
 
 /**
@@ skipping 19 matching lines @@
 
   List<TypeParameterElementForLink> get typeParameters {
     if (_typeParameters == null) {
       int enclosingNestingLevel =
           enclosingTypeParameterContext?.typeParameterNestingLevel ?? 0;
       int numTypeParameters = _unlinkedTypeParams.length;
       _typeParameters =
           new List<TypeParameterElementForLink>(numTypeParameters);
       for (int i = 0; i < numTypeParameters; i++) {
         _typeParameters[i] = new TypeParameterElementForLink(
-            _unlinkedTypeParams[i], enclosingNestingLevel + i);
+            this, _unlinkedTypeParams[i], enclosingNestingLevel + i);
       }
     }
     return _typeParameters;
   }
 
   /**
    * Get a list of [TypeParameterType] objects corresponding to the
    * element's type parameters.
    */
   List<TypeParameterType> get typeParameterTypes {
@@ skipping 320 matching lines @@
           List<int> implicitFunctionTypeIndices) =>
       DynamicTypeImpl.instance;
 
   ReferenceableElementForLink getContainedName(String name) {
     return new NonstaticMemberElementForLink(_constNode);
   }
 
   @override
   noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
 }