Make IndexableObjectKind parameterized.

pkg/analysis_server/lib/plugin/index/index_core.dart

 // Copyright (c) 2015, 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 analysis_server.plugin.index.index_core;
 
 import 'dart:async';
 import 'dart:collection';
 
 import 'package:analysis_server/src/services/index/index.dart';
 import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/source.dart';
 
 /**
  * Return the integer value that corresponds to the given [string]. The value of
  * [string] may be `null`.
  *
  * Clients are not expected to implement this signature. A function of this type
  * is provided by the framework to clients in order to implement the method
  * [IndexableObjectKind.encodeHash].
  */
 typedef int StringToInt(String string);
 
 /**
  * An object that can have a [Relationship] with various [Location]s in a code
  * base. The object is abstractly represented by a [kind] and an [offset] within
- * a [source].
+ * a file with the [filePath].
  *
  * Clients must ensure that two distinct objects in the same source cannot have
  * the same kind and offset. Failure to do so will make it impossible for
  * clients to identify the model element corresponding to the indexable object.
  *
  * Clients are expected to subtype this class when implementing plugins.
  */
 abstract class IndexableObject {
   /**
    * Return the absolute path of the file containing the indexable object.
    */
   String get filePath;
 
   /**
    * Return the kind of this object.
    */
   IndexableObjectKind get kind;
 
   /**
-   * Return the offset of the indexable object within its source.
+   * Return the offset of the indexable object within its file.
    */
   int get offset;
 }
 
 /**
  * The kind associated with an [IndexableObject].
  *
  * Clients are expected to implement this class when implementing plugins.
  */
-abstract class IndexableObjectKind {
+abstract class IndexableObjectKind<T extends IndexableObject> {
   /**
    * The next available index for a newly created kind of indexable object.
    */
   static int _nextIndex = 0;
 
   /**
    * A table mapping indexes to object kinds.
    */
   static Map<int, IndexableObjectKind> _registry =
       new HashMap<int, IndexableObjectKind>();
 
   /**
    * Return the next available index for a newly created kind of indexable
    * object.
    */
   static int get nextIndex => _nextIndex++;
 
   /**
    * Return the unique index for this kind of indexable object. Implementations
    * should invoke [nextIndex] to allocate an index that cannot be used by any
    * other object kind.
    */
   int get index;
 
   /**
    * Return the indexable object of this kind that exists in the given
    * [context], in the source with the given [filePath], and at the given
    * [offset].
    */
-  IndexableObject decode(AnalysisContext context, String filePath, int offset);
+  T decode(AnalysisContext context, String filePath, int offset);
 
   /**
    * Returns the hash value that corresponds to the given [indexable].
    *
    * This hash is used to remember buckets with relations of the given
    * [indexable]. Usually the name of the indexable object is encoded
    * using [stringToInt] and mixed with other information to produce the final
    * result.
    *
    * Clients must ensure that the same value is returned for the same object.
    *
    * Returned values must have good selectivity, e.g. if it is possible that
    * there are many different objects with the same name, then additional
    * information should be mixed in, for example the hash of the source that
    * declares the given [indexable].
    *
    * Clients don't have to use name to compute this result, so if an indexable
    * object does not have a name, some other value may be returned, but it still
    * must be always the same for the same object and have good selectivity.
    */
-  int encodeHash(StringToInt stringToInt, IndexableObject indexable);
+  int encodeHash(StringToInt stringToInt, T indexable);
 
   /**
    * Return the object kind with the given [index].
    */
   static IndexableObjectKind getKind(int index) {
     return _registry[index];
   }
 
   /**
    * Register the given object [kind] so that it can be found by it's unique
@@ skipping 152 matching lines @@
  */
 abstract class Relationship {
   /**
    * Return a relationship that has the given [identifier]. If the relationship
    * has already been created, then it will be returned, otherwise a new
    * relationship will be created
    */
   factory Relationship(String identifier) =>
       RelationshipImpl.getRelationship(identifier);
 }