Add tests for indexing.

pkg/analyzer/lib/src/summary/index_unit.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.
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart';
 import 'package:analyzer/dart/ast/visitor.dart';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
 import 'package:analyzer/src/generated/utilities_dart.dart';
@@ skipping 57 matching lines @@
       return a.offset - b.offset;
     });
     for (int i = 0; i < elementInfoList.length; i++) {
       elementInfoList[i].id = i;
     }
     return new PackageIndexBuilder(
         elementLibraryUris: _elementLibraryUris,
         elementUnitUris: _elementUnitUris,
         elementUnits: elementInfoList.map((e) => e.unitId).toList(),
         elementOffsets: elementInfoList.map((e) => e.offset).toList(),
+        elementKinds: elementInfoList.map((e) => e.kind).toList(),
         uris: _uris,
         units: _units.map((unit) => unit.assemble()).toList());
   }
 
   /**
    * Index the given fully resolved [unit].
    */
   void index(CompilationUnit unit) {
     CompilationUnitElement unitElement = unit.element;
     _UnitIndexAssembler assembler = new _UnitIndexAssembler(this, unitElement);
     _units.add(assembler);
     unit.accept(new _IndexContributor(assembler));
   }
 
   /**
    * Return the unique [_ElementInfo] corresponding the [element].  The field
    * [_ElementInfo.id] is filled by [assemble] during final sorting.
    */
   _ElementInfo _getElementInfo(Element element) {
     return _elementMap.putIfAbsent(element, () {
       CompilationUnitElement unitElement = getUnitElement(element);
       int unitId = _getUnitElementId(unitElement);
-      return new _ElementInfo(unitId, element.nameOffset);
+      int offset = element.nameOffset;
+      if (element is LibraryElement || element is CompilationUnitElement) {
+        offset = 0;
+      }
+      IndexElementKind kind = getIndexElementKind(element);
+      return new _ElementInfo(unitId, offset, kind);
     });
   }
 
   /**
    * Add information about [unitElement] to [_elementUnitUris] and
    * [_elementLibraryUris] if necessary, and return the location in those
    * arrays representing [unitElement].
    */
   int _getUnitElementId(CompilationUnitElement unitElement) {
     return _elementUnitMap.putIfAbsent(unitElement, () {
@@ skipping 12 matching lines @@
   int _getUriId(Uri uri) {
     String str = uri.toString();
     return _uriMap.putIfAbsent(str, () {
       int id = _uris.length;
       _uris.add(str);
       return id;
     });
   }
 
   /**
+   * Return the kind of the given [element].
+   */
+  static IndexElementKind getIndexElementKind(Element element) {
+    if (element is ConstructorElement && element.isSynthetic) {

[Paul Berry, 2016/02/26 19:02:05]

Why are only synthetic constructors classified as IndexElementKind.constructor?

If this is really what we want, consider renaming IndexElementKind.constructor
to IndexElementKind.syntheticConstructor and IndexElementKind.element to
IndexElementKind.other so that the expectation is clear.

+      return IndexElementKind.constructor;
+    } else if (element is PropertyAccessorElement) {
+      return element.isGetter
+          ? IndexElementKind.getter
+          : IndexElementKind.setter;
+    }
+    return IndexElementKind.element;
+  }
+
+  /**
    * Return the [CompilationUnitElement] that should be used for [element].
    * Throw [StateError] if the [element] is not linked into a unit.
    */
   static CompilationUnitElement getUnitElement(Element element) {
     for (Element e = element; e != null; e = e.enclosingElement) {
       if (e is CompilationUnitElement) {
         return e;
       }
       if (e is LibraryElement) {
         return e.definingCompilationUnit;
       }
     }
     throw new StateError(element.toString());
   }
 }
 
 /**
  * Information about an element referenced in index.
  */
 class _ElementInfo {
+  static const int KIND_ELEMENT = 0;

[Paul Berry, 2016/02/26 19:02:05]

I don't see where these are used, and I'm concerned that they duplicate the
functionality of IndexElementKind.

+  static const int KIND_GETTER = 1;
+  static const int KIND_SETTER = 2;
+  static const int KIND_CONSTRUCTOR = 3;
+
   /**
    * The identifier of the [CompilationUnitElement] containing this element.
    */
   final int unitId;
 
   /**
    * The name offset of the element.
    */
   final int offset;
 
   /**
+   * The kind of the element.
+   */
+  final IndexElementKind kind;
+
+  /**
    * The unique id of the element.  It is set after indexing of the whole
    * package is done and we are assembling the full package index.
    */
   int id;
 
-  _ElementInfo(this.unitId, this.offset);
+  _ElementInfo(this.unitId, this.offset, this.kind);
 }
 
 /**
  * Visits a resolved AST and adds relationships into [_UnitIndexAssembler].
  */
 class _IndexContributor extends GeneralizingAstVisitor {
   final _UnitIndexAssembler assembler;
 
   _IndexContributor(this.assembler);
 
@@ skipping 21 matching lines @@
       }
     }
     if (implementsClause != null) {
       for (TypeName interfaceNode in implementsClause.interfaces) {
         recordSuperType(interfaceNode, IndexRelationKind.IS_IMPLEMENTED_BY);
       }
     }
   }
 
   /**
-   * Records reference to defining [CompilationUnitElement] of the given
-   * [LibraryElement].
-   */
-  void recordLibraryReference(UriBasedDirective node, LibraryElement library) {
-    recordRelation(library, IndexRelationKind.IS_REFERENCED_BY, node?.uri);
-  }
-
-  /**
    * Record reference to the given operator [Element] and name.
    */
   void recordOperatorReference(Token operator, Element element) {
     recordRelationToken(element, IndexRelationKind.IS_INVOKED_BY, operator);
     // TODO(scheglov) do we need this?
 //    // prepare location
 //    LocationImpl location = _createLocationForToken(operator, element != null);
 //    // record name reference
 //    {
 //      String name = operator.lexeme;
@@ skipping 28 matching lines @@
   }
 
   /**
    * Record that [element] has a relation of the given [kind] at the given
    * [offset] and [length].
    */
   void recordRelationOffset(
       Element element, IndexRelationKind kind, int offset, int length) {
     // Ignore elements that can't be referenced outside of the unit.
     if (element == null ||
+        element is FunctionElement &&
+            element.enclosingElement is ExecutableElement ||
+        element is LabelElement ||
         element is LocalVariableElement ||
         element is ParameterElement &&
             element.parameterKind != ParameterKind.NAMED ||
-        element is FunctionElement &&
-            element.enclosingElement is ExecutableElement) {
+        element is PrefixElement ||
+        element is TypeParameterElement) {
       return;
     }
     // Add the relation.
     assembler.addRelation(element, kind, offset, length);
   }
 
   /**
    * Record that [element] has a relation of the given [kind] at the location
    * of the given [token].
    */
@@ skipping 26 matching lines @@
 //      IndexableElement indexable = new IndexableElement(element);
 //      int offset = element.nameOffset;
 //      int length = element.nameLength;
 //      LocationImpl location = new LocationImpl(indexable, offset, length);
 //      recordRelationshipElement(
 //          _libraryElement, IndexConstants.DEFINES, location);
 //      _store.recordTopLevelDeclaration(element);
 //    }
   }
 
-  void recordUriFileReference(UriBasedDirective directive) {
-    Element element = directive.element;
+  void recordUriReference(Element element, UriBasedDirective directive) {
     recordRelation(element, IndexRelationKind.IS_REFERENCED_BY, directive.uri);
   }
 
   @override
   visitAssignmentExpression(AssignmentExpression node) {
     recordOperatorReference(node.operator, node.bestElement);
     super.visitAssignmentExpression(node);
   }
 
   @override
@@ skipping 58 matching lines @@
   @override
   visitEnumDeclaration(EnumDeclaration node) {
     ClassElement element = node.element;
     recordTopLevelElementDefinition(element);
     super.visitEnumDeclaration(node);
   }
 
   @override
   visitExportDirective(ExportDirective node) {
     ExportElement element = node.element;
-    if (element != null) {
-      LibraryElement expLibrary = element.exportedLibrary;
-      recordLibraryReference(node, expLibrary);
-    }
-    recordUriFileReference(node);
+    recordUriReference(element?.exportedLibrary, node);
     super.visitExportDirective(node);
   }
 
   @override
   visitFunctionDeclaration(FunctionDeclaration node) {
     Element element = node.element;
     recordTopLevelElementDefinition(element);
     super.visitFunctionDeclaration(node);
   }
 
   @override
   visitFunctionTypeAlias(FunctionTypeAlias node) {
     Element element = node.element;
     recordTopLevelElementDefinition(element);
     super.visitFunctionTypeAlias(node);
   }
 
   @override
   visitImportDirective(ImportDirective node) {
     ImportElement element = node.element;
-    if (element != null) {
-      LibraryElement impLibrary = element.importedLibrary;
-      recordLibraryReference(node, impLibrary);
-    }
-    recordUriFileReference(node);
+    recordUriReference(element?.importedLibrary, node);
     super.visitImportDirective(node);
   }
 
   @override
   visitIndexExpression(IndexExpression node) {
     MethodElement element = node.bestElement;
     if (element is MethodElement) {
       Token operator = node.leftBracket;
       recordRelationToken(element, IndexRelationKind.IS_INVOKED_BY, operator);
     }
     super.visitIndexExpression(node);
   }
 
   @override
   visitMethodInvocation(MethodInvocation node) {
     SimpleIdentifier name = node.methodName;
     // TODO(scheglov) do we need this?
 //    LocationImpl location = _createLocationForNode(name);
 //    // name invocation
 //    recordRelationshipIndexable(
 //        new IndexableName(name.name), IndexConstants.IS_INVOKED_BY, location);
     // element invocation
     Element element = name.bestElement;
     if (element is MethodElement ||
         element is PropertyAccessorElement ||
         element is FunctionElement ||
         element is VariableElement) {
-      recordRelation(element, IndexRelationKind.IS_INVOKED_BY, node);
+      recordRelation(element, IndexRelationKind.IS_INVOKED_BY, name);
     } else if (element is ClassElement) {
-      recordRelation(element, IndexRelationKind.IS_REFERENCED_BY, node);
+      recordRelation(element, IndexRelationKind.IS_REFERENCED_BY, name);
     }
     node.target?.accept(this);
     node.argumentList?.accept(this);
   }
 
   @override
   visitPartDirective(PartDirective node) {
-    recordRelation(node.element, IndexRelationKind.IS_REFERENCED_BY, node);
-    recordUriFileReference(node);
+    Element element = node.element;
+    recordUriReference(element, node);
     super.visitPartDirective(node);
   }
 
   @override
-  visitPartOfDirective(PartOfDirective node) {
-    recordRelation(node.element, IndexRelationKind.IS_REFERENCED_BY, node);
-  }
-
-  @override
   visitPostfixExpression(PostfixExpression node) {
     recordOperatorReference(node.operator, node.bestElement);
     super.visitPostfixExpression(node);
   }
 
   @override
   visitPrefixExpression(PrefixExpression node) {
     recordOperatorReference(node.operator, node.bestElement);
     super.visitPrefixExpression(node);
   }
@@ skipping 39 matching lines @@
       recordRelation(element.field, IndexRelationKind.IS_REFERENCED_BY, node);
       return;
     }
     // record specific relations
     // TODO(scheglov) consider removing the conditions
     if (element is ClassElement ||
         element is FunctionElement ||
         element is FunctionTypeAliasElement ||
         element is LabelElement ||
         element is MethodElement ||
+        element is ParameterElement ||
         element is PrefixElement ||
         element is PropertyAccessorElement ||
         element is PropertyInducingElement ||
         element is TypeParameterElement) {
       recordRelation(element, IndexRelationKind.IS_REFERENCED_BY, node);
     }
   }
 
   @override
   visitSuperConstructorInvocation(SuperConstructorInvocation node) {
@@ skipping 95 matching lines @@
     });
     return new UnitIndexBuilder(
         elements: relations.map((r) => r.elementInfo.id).toList(),
         kinds: relations.map((r) => r.kind).toList(),
         locationOffsets: relations.map((r) => r.offset).toList(),
         locationLengths: relations.map((r) => r.length).toList(),
         libraryUri: pkg._getUriId(unitElement.library.source.uri),
         unitUri: pkg._getUriId(unitElement.source.uri));
   }
 }