Index defined top-level and class member names.

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/src/generated/utilities_dart.dart';
 import 'package:analyzer/src/summary/format.dart';
@@ skipping 13 matching lines @@
 
   /**
    * Map associating [CompilationUnitElement]s with their identifiers, which
    * are indices into [_elementLibraryUris] and [_elementUnitUris].
    */
   final Map<CompilationUnitElement, int> _elementUnitMap =
       <CompilationUnitElement, int>{};
 
   /**
    * Each item of this list corresponds to the library URI of a unique
-   * [CompilationUnitElement].  It is an index into [_uris].
+   * [CompilationUnitElement].  It is an index into [_strings].
    */
   final List<int> _elementLibraryUris = <int>[];
 
   /**
    * Each item of this list corresponds to the unit URI of a unique
-   * [CompilationUnitElement].  It is an index into [_uris].
+   * [CompilationUnitElement].  It is an index into [_strings].
    */
   final List<int> _elementUnitUris = <int>[];
 
   /**
-   * Map associating URIs with their identifiers, which are indices
-   * into [_uris].
+   * Map associating strings with their identifiers, which are indices
+   * into [_strings].
    */
-  final Map<String, int> _uriMap = <String, int>{};
+  final Map<String, int> _stringMap = <String, int>{};
 
   /**
-   * List of unique URIs used in this index.
+   * List of unique strings used in this index.
    */
-  final List<String> _uris = <String>[];
+  final List<String> _strings = <String>[];
 
   /**
    * List of information about each unit indexed in this index.
    */
   final List<_UnitIndexAssembler> _units = <_UnitIndexAssembler>[];
 
   /**
    * Assemble a new [PackageIndexBuilder] using the information gathered by
    * [index].
    */
   PackageIndexBuilder assemble() {
     List<_ElementInfo> elementInfoList = _elementMap.values.toList();
     elementInfoList.sort((a, b) {
       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,
+        strings: _strings,
         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);
@@ skipping 11 matching lines @@
       int offset = element.nameOffset;
       if (element is LibraryElement || element is CompilationUnitElement) {
         offset = 0;
       }
       IndexSyntheticElementKind kind = getIndexElementKind(element);
       return new _ElementInfo(unitId, offset, kind);
     });
   }
 
   /**
+   * Add information about [str] to [_strings] if necessary, and return the
+   * location in this array representing [str].
+   */
+  int _getStringId(String str) {
+    return _stringMap.putIfAbsent(str, () {
+      int id = _strings.length;
+      _strings.add(str);
+      return id;
+    });
+  }
+
+  /**
    * 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, () {
       assert(_elementLibraryUris.length == _elementUnitUris.length);
       int id = _elementUnitUris.length;
       _elementLibraryUris.add(_getUriId(unitElement.library.source.uri));
       _elementUnitUris.add(_getUriId(unitElement.source.uri));
       return id;
     });
   }
 
   /**
-   * Add information about [uri] to [_uris] if necessary, and return the
-   * location in this array representing [uri].
+   * Return the identifier corresponding to [uri].
    */
   int _getUriId(Uri uri) {
     String str = uri.toString();
-    return _uriMap.putIfAbsent(str, () {
-      int id = _uris.length;
-      _uris.add(str);
-      return id;
-    });
+    return _getStringId(str);
   }
 
   /**
    * Return the kind of the given [element].
    */
   static IndexSyntheticElementKind getIndexElementKind(Element element) {
     if (element.isSynthetic) {
       if (element is ConstructorElement) {
         return IndexSyntheticElementKind.constructor;
       }
@@ skipping 17 matching lines @@
       }
       if (e is LibraryElement) {
         return e.definingCompilationUnit;
       }
     }
     throw new StateError(element.toString());
   }
 }
 
 /**
+ * Information about a single defined name.  Any [_DefinedNameInfo] is always
+ * part of a [_UnitIndexAssembler], so [offset] should be understood within the
+ * context of the compilation unit pointed to by the [_UnitIndexAssembler].
+ */
+class _DefinedNameInfo {
+  final int nameId;

[Paul Berry, 2016/02/29 20:26:02]

Please document what this id refers to (I assume it's an index into
PackageIndexAssembler._strings)

[scheglov, 2016/02/29 20:47:44]

Fixed in https://codereview.chromium.org/1753433002

+  final IndexNameKind kind;
+  final int offset;
+
+  _DefinedNameInfo(this.nameId, this.kind, this.offset);
+}
+
+/**
  * Information about an element referenced in index.
  */
 class _ElementInfo {
   /**
    * The identifier of the [CompilationUnitElement] containing this element.
    */
   final int unitId;
 
   /**
    * The name offset of the element.
@@ skipping 16 matching lines @@
 
 /**
  * Visits a resolved AST and adds relationships into [_UnitIndexAssembler].
  */
 class _IndexContributor extends GeneralizingAstVisitor {
   final _UnitIndexAssembler assembler;
 
   _IndexContributor(this.assembler);
 
   /**
+   * Record definition of the given [element].
+   */
+  void recordDefinedElement(Element element) {
+    if (element != null) {
+      String name = element.displayName;
+      int offset = element.nameOffset;
+      Element enclosing = element.enclosingElement;
+      if (enclosing is CompilationUnitElement) {
+        assembler.defineName(name, IndexNameKind.topLevel, offset);
+      } else if (enclosing is ClassElement) {
+        assembler.defineName(name, IndexNameKind.classMember, offset);
+      }
+    }
+  }
+
+  /**
    * 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 64 matching lines @@
    * Record a relation between a super [typeName] and its [Element].
    */
   void recordSuperType(TypeName typeName, IndexRelationKind kind) {
     Identifier name = typeName?.name;
     if (name != null) {
       recordRelation(name.staticElement, kind, name);
       typeName.typeArguments?.accept(this);
     }
   }
 
-  /**
-   * Record the top-level [element] definition.
-   */
-  void recordTopLevelElementDefinition(Element element) {
-    // TODO(scheglov) do we need this?
-//    if (element?.enclosingElement is CompilationUnitElement) {
-//      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 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
   visitBinaryExpression(BinaryExpression node) {
     recordOperatorReference(node.operator, node.bestElement);
     super.visitBinaryExpression(node);
   }
 
   @override
   visitClassDeclaration(ClassDeclaration node) {
-    ClassElement element = node.element;
-    recordTopLevelElementDefinition(element);
     if (node.extendsClause == null) {
-      ClassElement objectElement = element.supertype?.element;
+      ClassElement objectElement = node.element.supertype?.element;
       recordRelationOffset(
           objectElement, IndexRelationKind.IS_EXTENDED_BY, node.name.offset, 0);
     }
     super.visitClassDeclaration(node);
   }
 
   @override
-  visitClassTypeAlias(ClassTypeAlias node) {
-    ClassElement element = node.element;
-    recordTopLevelElementDefinition(element);
-    super.visitClassTypeAlias(node);
-  }
-
-  @override
   visitConstructorFieldInitializer(ConstructorFieldInitializer node) {
     SimpleIdentifier fieldName = node.fieldName;
     if (fieldName != null) {
       Element element = fieldName.staticElement;
       recordRelation(element, IndexRelationKind.IS_REFERENCED_BY, fieldName);
     }
     node.expression?.accept(this);
   }
 
   @override
@@ skipping 15 matching lines @@
           element, IndexRelationKind.IS_REFERENCED_BY, offset, length);
     } else {
       int offset = node.type.end;
       recordRelationOffset(
           element, IndexRelationKind.IS_REFERENCED_BY, offset, 0);
     }
     super.visitConstructorName(node);
   }
 
   @override
-  visitEnumDeclaration(EnumDeclaration node) {
-    ClassElement element = node.element;
-    recordTopLevelElementDefinition(element);
-    super.visitEnumDeclaration(node);
-  }
-
-  @override
   visitExportDirective(ExportDirective node) {
     ExportElement element = node.element;
     recordUriReference(element?.exportedLibrary, node);
     super.visitExportDirective(node);
   }
 
   @override
   visitExtendsClause(ExtendsClause node) {
     recordSuperType(node.superclass, IndexRelationKind.IS_EXTENDED_BY);
   }
 
   @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
   visitImplementsClause(ImplementsClause node) {
     for (TypeName typeName in node.interfaces) {
       recordSuperType(typeName, IndexRelationKind.IS_IMPLEMENTED_BY);
     }
   }
 
   @override
   visitImportDirective(ImportDirective node) {
     ImportElement element = node.element;
     recordUriReference(element?.importedLibrary, node);
@@ skipping 65 matching lines @@
     } else {
       int offset = node.thisKeyword.end;
       recordRelationOffset(
           element, IndexRelationKind.IS_REFERENCED_BY, offset, 0);
     }
     super.visitRedirectingConstructorInvocation(node);
   }
 
   @override
   visitSimpleIdentifier(SimpleIdentifier node) {
+    Element element = node.bestElement;
     // TODO(scheglov) do we need this?
 //    IndexableName indexableName = new IndexableName(node.name);
 //    LocationImpl location = _createLocationForNode(node);
 //    if (location == null) {
 //      return;
 //    }
     // name in declaration
     if (node.inDeclarationContext()) {
-      // TODO(scheglov) do we need this?
-//      recordRelationshipIndexable(
-//          indexableName, IndexConstants.NAME_IS_DEFINED_BY, location);
+      recordDefinedElement(element);
       return;
     }
-    Element element = node.bestElement;
     // this.field parameter
     if (element is FieldFormalParameterElement) {
       recordRelation(element.field, IndexRelationKind.IS_REFERENCED_BY, node);
       return;
     }
     // record specific relations
     IndexRelationKind kind = node.isQualified
         ? IndexRelationKind.IS_REFERENCED_QUALIFIED_BY
         : IndexRelationKind.IS_REFERENCED_BY;
     recordRelation(element, kind, node);
@@ skipping 19 matching lines @@
   visitTypeName(TypeName node) {
     AstNode parent = node.parent;
     if (parent is ClassTypeAlias && parent.superclass == node) {
       recordSuperType(node, IndexRelationKind.IS_EXTENDED_BY);
     } else {
       super.visitTypeName(node);
     }
   }
 
   @override
-  visitVariableDeclaration(VariableDeclaration node) {
-    VariableElement element = node.element;
-    recordTopLevelElementDefinition(element);
-    // TODO(scheglov) do we need this?
-//    // record declaration
-//    {
-//      SimpleIdentifier name = node.name;
-//      LocationImpl location = _createLocationForNode(name);
-//      location = _getLocationWithExpressionType(location, node.initializer);
-//      recordRelationshipElement(
-//          element, IndexConstants.NAME_IS_DEFINED_BY, location);
-//    }
-    super.visitVariableDeclaration(node);
-  }
-
-  @override
   visitWithClause(WithClause node) {
     for (TypeName typeName in node.mixinTypes) {
       recordSuperType(typeName, IndexRelationKind.IS_MIXED_IN_BY);
     }
   }
 }
 
 /**
  * Information about a single relation.  Any [_RelationInfo] is always part
  * of a [_UnitIndexAssembler], so [offset] and [length] should be understood
  * within the context of the compilation unit pointed to by the
  * [_UnitIndexAssembler].
  */
 class _RelationInfo {
   final _ElementInfo elementInfo;
   final IndexRelationKind kind;
   final int offset;
   final int length;
 
   _RelationInfo(this.elementInfo, this.kind, this.offset, this.length);
 }
 
 /**
  * Assembler of a single [CompilationUnit] index.  The intended usage sequence:
  *
+ *  - Call [defineName] for name defined in the compilation unit.

[Paul Berry, 2016/02/29 20:26:02]

s/for name/for each name/

  *  - Call [addRelation] for each relation found in the compilation unit.
  *  - Assign ids to all the [_ElementInfo] objects reachable from [relations].
  *  - Call [assemble] to produce the final unit index.
  */
 class _UnitIndexAssembler {
   final PackageIndexAssembler pkg;
   final CompilationUnitElement unitElement;
+  final List<_DefinedNameInfo> definedNames = <_DefinedNameInfo>[];
   final List<_RelationInfo> relations = <_RelationInfo>[];
 
   _UnitIndexAssembler(this.pkg, this.unitElement);
 
   void addRelation(
       Element element, IndexRelationKind kind, int offset, int length) {
     try {
       _ElementInfo elementInfo = pkg._getElementInfo(element);
       relations.add(new _RelationInfo(elementInfo, kind, offset, length));
     } on StateError {}
   }
 
   /**
    * Assemble a new [UnitIndexBuilder] using the information gathered
-   * by [addRelation]
+   * by [addRelation] and [defineName].
    */
   UnitIndexBuilder assemble() {
     relations.sort((a, b) {
       return a.elementInfo.id - b.elementInfo.id;
     });
+    definedNames.sort((a, b) {
+      return a.nameId - b.nameId;
+    });
     return new UnitIndexBuilder(
+        definedNames: definedNames.map((n) => n.nameId).toList(),
+        definedNameKinds: definedNames.map((n) => n.kind).toList(),
+        definedNameOffsets: definedNames.map((n) => n.offset).toList(),
         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));
   }
+
+  void defineName(String name, IndexNameKind kind, int offset) {
+    int nameId = pkg._getStringId(name);
+    definedNames.add(new _DefinedNameInfo(nameId, kind, offset));
+  }
 }