Issue 26063. Index declarations in even partically analyzed units.

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.
@@ skipping 52 matching lines @@
    */
   final Map<String, _StringInfo> _stringMap = <String, _StringInfo>{};
 
   /**
    * 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].
+   * [indexDeclarations] or [indexUnit].
    */
   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();
     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 declarations in the given partially resolved [unit].
+   */
+  void indexDeclarations(CompilationUnit unit) {
+    int unitId = _getUnitId(unit.element);
+    _UnitIndexAssembler assembler = new _UnitIndexAssembler(this, unitId);
+    _units.add(assembler);
+    unit.accept(new _IndexDeclarationContributor(assembler));
+  }
+
+  /**
    * Index the given fully resolved [unit].
    */
-  void index(CompilationUnit unit) {
+  void indexUnit(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.
    */
@@ skipping 148 matching lines @@
   final int length;
   final bool isQualified;
 
   _ElementRelationInfo(
       this.elementInfo, this.kind, this.offset, this.length, this.isQualified);
 }
 
 /**
  * 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);
-      }
-    }
-  }
+class _IndexContributor extends _IndexDeclarationContributor {
+  _IndexContributor(_UnitIndexAssembler assembler) : super(assembler);
 
   void recordIsAncestorOf(Element descendant) {
     _recordIsAncestorOf(descendant, descendant, false, <ClassElement>[]);
   }
 
   /**
    * Record that the name [node] has a relation of the given [kind].
    */
   void recordNameRelation(
       SimpleIdentifier node, IndexRelationKind kind, bool isQualified) {
@@ skipping 235 matching lines @@
     } else {
       int offset = node.thisKeyword.end;
       recordRelationOffset(
           element, IndexRelationKind.IS_REFERENCED_BY, offset, 0, true);
     }
     super.visitRedirectingConstructorInvocation(node);
   }
 
   @override
   visitSimpleIdentifier(SimpleIdentifier node) {
-    Element element = node.bestElement;
     // name in declaration
     if (node.inDeclarationContext()) {
+      Element element = node.staticElement;
       recordDefinedElement(element);
       return;
     }
+    Element element = node.bestElement;
     // record unresolved name reference
     bool isQualified = _isQualified(node);
     if (element == null) {
       bool inGetterContext = node.inGetterContext();
       bool inSetterContext = node.inSetterContext();
       IndexRelationKind kind;
       if (inGetterContext && inSetterContext) {
         kind = IndexRelationKind.IS_READ_WRITTEN_BY;
       } else if (inGetterContext) {
         kind = IndexRelationKind.IS_READ_BY;
@@ skipping 112 matching lines @@
       _recordIsAncestorOf(descendant, mixinType.element, true, visitedElements);
     }
     for (InterfaceType implementedType in ancestor.interfaces) {
       _recordIsAncestorOf(
           descendant, implementedType.element, true, visitedElements);
     }
   }
 }
 
 /**
+ * Visits a resolved AST and adds relationships into [_UnitIndexAssembler].
+ */
+class _IndexDeclarationContributor extends GeneralizingAstVisitor {
+  final _UnitIndexAssembler assembler;
+
+  _IndexDeclarationContributor(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);
+      }
+    }
+  }
+
+  @override
+  visitSimpleIdentifier(SimpleIdentifier node) {
+    if (node.inDeclarationContext()) {
+      Element element = node.staticElement;
+      recordDefinedElement(element);
+      return;
+    }
+  }
+}
+
+/**
  * Information about a single name relation.  Any [_NameRelationInfo] is always
  * part of a [_UnitIndexAssembler], so [offset] should be understood within the
  * context of the compilation unit pointed to by the [_UnitIndexAssembler].
  */
 class _NameRelationInfo {
   /**
    * The information about the name returned from
    * [PackageIndexAssembler._getStringInfo].
    */
   final _StringInfo nameInfo;
@@ skipping 88 matching lines @@
         usedNameOffsets: nameRelations.map((r) => r.offset).toList(),
         usedNameIsQualifiedFlags:
             nameRelations.map((r) => r.isQualified).toList());
   }
 
   void defineName(String name, IndexNameKind kind, int offset) {
     _StringInfo nameInfo = pkg._getStringInfo(name);
     definedNames.add(new _DefinedNameInfo(nameInfo, kind, offset));
   }
 }