Fix for indexing synthetic elements.

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/dart/element/member.dart';
 import 'package:analyzer/src/generated/utilities_dart.dart';
 import 'package:analyzer/src/summary/format.dart';
 import 'package:analyzer/src/summary/idl.dart';
 
 /**
+ * TODO(scheglov) add to the `meta` package.
+ */
+const visibleForTesting = const Object();
+
+/**
+ * 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.
+   */
+  final int offset;
+
+  /**
+   * The kind of the element.
+   */
+  final IndexSyntheticElementKind 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, this.kind) {
+    assert(offset >= 0);
+  }
+}
+
+/**
  * Object that gathers information about the whole package index and then uses
  * it to assemble a new [PackageIndexBuilder].  Call [index] on each compilation
  * unit to be indexed, then call [assemble] to retrieve the complete index for
  * the package.
  */
 class PackageIndexAssembler {
   /**
-   * Map associating referenced elements with their [_ElementInfo]s.
+   * Map associating referenced elements with their [ElementInfo]s.
    */
-  final Map<Element, _ElementInfo> _elementMap = <Element, _ElementInfo>{};
+  final Map<Element, ElementInfo> _elementMap = <Element, ElementInfo>{};
 
   /**
    * Map associating [CompilationUnitElement]s with their identifiers, which
    * are indices into [_unitLibraryUris] and [_unitUnitUris].
    */
   final Map<CompilationUnitElement, int> _unitMap =
       <CompilationUnitElement, int>{};
 
   /**
    * Each item of this list corresponds to the library URI of a unique
@@ skipping 24 matching lines @@
   PackageIndexBuilder assemble() {
     // sort strings end set IDs
     List<_StringInfo> stringInfoList = _stringMap.values.toList();
     stringInfoList.sort((a, b) {
       return a.value.compareTo(b.value);
     });
     for (int i = 0; i < stringInfoList.length; i++) {
       stringInfoList[i].id = i;
     }
     // sort elements and set IDs
-    List<_ElementInfo> elementInfoList = _elementMap.values.toList();
+    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(
         unitLibraryUris: _unitLibraryUris.map((s) => s.id).toList(),
         unitUnitUris: _unitUnitUris.map((s) => s.id).toList(),
         elementUnits: elementInfoList.map((e) => e.unitId).toList(),
         elementOffsets: elementInfoList.map((e) => e.offset).toList(),
         elementKinds: elementInfoList.map((e) => e.kind).toList(),
         strings: stringInfoList.map((s) => s.value).toList(),
         units: _units.map((unit) => unit.assemble()).toList());
   }
 
   /**
    * Index the given fully resolved [unit].
    */
   void index(CompilationUnit unit) {
     int unitId = _getUnitId(unit.element);
     _UnitIndexAssembler assembler = new _UnitIndexAssembler(this, unitId);
     _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.
+   * Return the unique [ElementInfo] corresponding the [element].  The field
+   * [ElementInfo.id] is filled by [assemble] during final sorting.
    */
-  _ElementInfo _getElementInfo(Element element) {
+  ElementInfo _getElementInfo(Element element) {
     if (element is Member) {
       element = (element as Member).baseElement;
     }
     return _elementMap.putIfAbsent(element, () {
       CompilationUnitElement unitElement = getUnitElement(element);
       int unitId = _getUnitId(unitElement);
-      int offset = element.nameOffset;
-      if (element is LibraryElement || element is CompilationUnitElement) {
-        offset = 0;
-      }
-      IndexSyntheticElementKind kind = getIndexElementKind(element);
-      return new _ElementInfo(unitId, offset, kind);
+      return newElementInfo(unitId, element);
     });
   }
 
   /**
    * Return the unique [_StringInfo] corresponding the [str].  The field
    * [_StringInfo.id] is filled by [assemble] during final sorting.
    */
   _StringInfo _getStringInfo(String str) {
     return _stringMap.putIfAbsent(str, () {
       return new _StringInfo(str);
@@ skipping 18 matching lines @@
   /**
    * Return the unique [_StringInfo] corresponding [uri].  The field
    * [_StringInfo.id] is filled by [assemble] during final sorting.
    */
   _StringInfo _getUriInfo(Uri uri) {
     String str = uri.toString();
     return _getStringInfo(str);
   }
 
   /**
-   * Return the kind of the given [element].
-   */
-  static IndexSyntheticElementKind getIndexElementKind(Element element) {
-    if (element.isSynthetic) {
-      if (element is ConstructorElement) {
-        return IndexSyntheticElementKind.constructor;
-      }
-      if (element is PropertyAccessorElement) {
-        return element.isGetter
-            ? IndexSyntheticElementKind.getter
-            : IndexSyntheticElementKind.setter;
-      }
-    }
-    return IndexSyntheticElementKind.notSynthetic;
-  }
-
-  /**
    * 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());
   }
+
+  /**
+   * Return a new [ElementInfo] for the given [element] in the given [unitId].
+   * This method is static, so it cannot add any information to the index.
+   */
+  static ElementInfo newElementInfo(int unitId, Element element) {
+    IndexSyntheticElementKind kind = IndexSyntheticElementKind.notSynthetic;
+    if (element.isSynthetic) {
+      if (element is ConstructorElement) {
+        kind = IndexSyntheticElementKind.constructor;
+        element = element.enclosingElement;
+      } else if (element is PropertyAccessorElement) {
+        PropertyAccessorElement property = element;
+        kind = property.isGetter
+            ? IndexSyntheticElementKind.getter
+            : IndexSyntheticElementKind.setter;
+        element = element.enclosingElement;
+      } else {
+        throw new ArgumentError(
+            'Unsupported synthetic element ${element.runtimeType}');
+      }
+    }
+    int offset = element.nameOffset;
+    if (element is LibraryElement || element is CompilationUnitElement) {
+      offset = 0;
+    }
+    return new ElementInfo(unitId, offset, kind);
+  }
 }
 
 /**
  * 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 {
   /**
    * The information about the name returned from
    * [PackageIndexAssembler._getStringInfo].
    */
   final _StringInfo nameInfo;
 
   /**
    * The coarse-grained kind of the defined name.
    */
   final IndexNameKind kind;
 
   /**
    * The name offset of the defined element.
    */
   final int offset;
 
   _DefinedNameInfo(this.nameInfo, 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.
-   */
-  final int offset;
-
-  /**
-   * The kind of the element.
-   */
-  final IndexSyntheticElementKind 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, this.kind);
-}
-
-/**
- * Information about a string referenced in the index.
- */
-class _StringInfo {
-  /**
-   * The value of the string.
-   */
-  final String value;
-
-  /**
-   * The unique id of the string.  It is set after indexing of the whole
-   * package is done and we are assembling the full package index.
-   */
-  int id;
-
-  _StringInfo(this.value);
-}
-
-/**
  * Information about a single relation.  Any [_ElementRelationInfo] 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 _ElementRelationInfo {
-  final _ElementInfo elementInfo;
+  final ElementInfo elementInfo;
   final IndexRelationKind kind;
   final int offset;
   final int length;
   final bool isQualified;
 
   _ElementRelationInfo(
       this.elementInfo, this.kind, this.offset, this.length, this.isQualified);
 }
 
 /**
@@ skipping 400 matching lines @@
    * [PackageIndexAssembler._getStringInfo].
    */
   final _StringInfo nameInfo;
   final IndexRelationKind kind;
   final int offset;
 
   _NameRelationInfo(this.nameInfo, this.kind, this.offset);
 }
 
 /**
+ * Information about a string referenced in the index.
+ */
+class _StringInfo {
+  /**
+   * The value of the string.
+   */
+  final String value;
+
+  /**
+   * The unique id of the string.  It is set after indexing of the whole
+   * package is done and we are assembling the full package index.
+   */
+  int id;
+
+  _StringInfo(this.value);
+}
+
+/**
  * Assembler of a single [CompilationUnit] index.  The intended usage sequence:
  *
  *  - Call [defineName] for each name defined in the compilation unit.
  *  - Call [addElementRelation] for each element relation found in the
  *    compilation unit.
  *  - Call [addNameRelation] for each name relation found in the
  *    compilation unit.
- *  - Assign ids to all the [_ElementInfo] objects reachable from
+ *  - Assign ids to all the [ElementInfo] objects reachable from
  *    [elementRelations].
  *  - Call [assemble] to produce the final unit index.
  */
 class _UnitIndexAssembler {
   final PackageIndexAssembler pkg;
   final int unitId;
   final List<_DefinedNameInfo> definedNames = <_DefinedNameInfo>[];
   final List<_ElementRelationInfo> elementRelations = <_ElementRelationInfo>[];
   final List<_NameRelationInfo> nameRelations = <_NameRelationInfo>[];
 
   _UnitIndexAssembler(this.pkg, this.unitId);
 
   void addElementRelation(Element element, IndexRelationKind kind, int offset,
       int length, bool isQualified) {
     try {
-      _ElementInfo elementInfo = pkg._getElementInfo(element);
+      ElementInfo elementInfo = pkg._getElementInfo(element);
       elementRelations.add(new _ElementRelationInfo(
           elementInfo, kind, offset, length, isQualified));
     } on StateError {}
   }
 
   void addNameRelation(String name, IndexRelationKind kind, int offset) {
     _StringInfo nameId = pkg._getStringInfo(name);
     nameRelations.add(new _NameRelationInfo(nameId, kind, offset));
   }
 
@@ skipping 25 matching lines @@
         usedNames: nameRelations.map((r) => r.nameInfo.id).toList(),
         usedNameKinds: nameRelations.map((r) => r.kind).toList(),
         usedNameOffsets: nameRelations.map((r) => r.offset).toList());
   }
 
   void defineName(String name, IndexNameKind kind, int offset) {
     _StringInfo nameInfo = pkg._getStringInfo(name);
     definedNames.add(new _DefinedNameInfo(nameInfo, kind, offset));
   }
 }