Index unqualified unresolved used 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/dart/element/type.dart';
 import 'package:analyzer/src/dart/element/member.dart';
@@ skipping 25 matching lines @@
    */
   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) {
+    if (offset < 0) {
+      print(offset);

[Brian Wilkerson, 2016/03/11 22:50:06]

Debugging code?

+    }
     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.
  */
@@ skipping 241 matching lines @@
     }
   }
 
   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) {
+  void recordNameRelation(
+      SimpleIdentifier node, IndexRelationKind kind, bool isQualified) {
     if (node != null) {
-      assembler.addNameRelation(node.name, kind, node.offset);
+      assembler.addNameRelation(node.name, kind, node.offset, isQualified);
     }
   }
 
   /**
    * Record reference to the given operator [Element].
    */
   void recordOperatorReference(Token operator, Element element) {
     recordRelationToken(element, IndexRelationKind.IS_INVOKED_BY, operator);
   }
 
@@ skipping 164 matching lines @@
       Token operator = node.leftBracket;
       recordRelationToken(element, IndexRelationKind.IS_INVOKED_BY, operator);
     }
     super.visitIndexExpression(node);
   }
 
   @override
   visitMethodInvocation(MethodInvocation node) {
     SimpleIdentifier name = node.methodName;
     Element element = name.bestElement;
-    // qualified unresolved name invocation
+    // unresolved name invocation
     bool isQualified = node.realTarget != null;
-    if (isQualified && element == null) {
-      recordNameRelation(name, IndexRelationKind.IS_INVOKED_BY);
+    if (element == null) {
+      recordNameRelation(name, IndexRelationKind.IS_INVOKED_BY, isQualified);
     }
     // element invocation
     IndexRelationKind kind = element is ClassElement
         ? IndexRelationKind.IS_REFERENCED_BY
         : IndexRelationKind.IS_INVOKED_BY;
     recordRelation(element, kind, name, isQualified);
     node.target?.accept(this);
     node.argumentList?.accept(this);
   }
 
@@ skipping 33 matching lines @@
   }
 
   @override
   visitSimpleIdentifier(SimpleIdentifier node) {
     Element element = node.bestElement;
     // name in declaration
     if (node.inDeclarationContext()) {
       recordDefinedElement(element);
       return;
     }
-    // record qualified unresolved name reference
+    // record unresolved name reference
     bool isQualified = _isQualified(node);
-    if (isQualified && element == null) {
+    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;
       } else {
         kind = IndexRelationKind.IS_WRITTEN_BY;
       }
-      recordNameRelation(node, kind);
+      recordNameRelation(node, kind, isQualified);
     }
     // this.field parameter
     if (element is FieldFormalParameterElement) {
       AstNode parent = node.parent;
       IndexRelationKind kind =
           parent is FieldFormalParameter && parent.identifier == node
               ? IndexRelationKind.IS_WRITTEN_BY
               : IndexRelationKind.IS_REFERENCED_BY;
       recordRelation(element.field, kind, node, true);
       return;
@@ skipping 110 matching lines @@
  * context of the compilation unit pointed to by the [_UnitIndexAssembler].
  */
 class _NameRelationInfo {
   /**
    * The information about the name returned from
    * [PackageIndexAssembler._getStringInfo].
    */
   final _StringInfo nameInfo;
   final IndexRelationKind kind;
   final int offset;
+  final bool isQualified;
 
-  _NameRelationInfo(this.nameInfo, this.kind, this.offset);
+  _NameRelationInfo(this.nameInfo, this.kind, this.offset, this.isQualified);
 }
 
 /**
  * Information about a string referenced in the index.
  */
 class _StringInfo {
   /**
    * The value of the string.
    */
   final String value;
@@ skipping 30 matching lines @@
 
   void addElementRelation(Element element, IndexRelationKind kind, int offset,
       int length, bool isQualified) {
     try {
       ElementInfo elementInfo = pkg._getElementInfo(element);
       elementRelations.add(new _ElementRelationInfo(
           elementInfo, kind, offset, length, isQualified));
     } on StateError {}
   }
 
-  void addNameRelation(String name, IndexRelationKind kind, int offset) {
+  void addNameRelation(
+      String name, IndexRelationKind kind, int offset, bool isQualified) {
     _StringInfo nameId = pkg._getStringInfo(name);
-    nameRelations.add(new _NameRelationInfo(nameId, kind, offset));
+    nameRelations.add(new _NameRelationInfo(nameId, kind, offset, isQualified));
   }
 
   /**
    * Assemble a new [UnitIndexBuilder] using the information gathered
    * by [addElementRelation] and [defineName].
    */
   UnitIndexBuilder assemble() {
     definedNames.sort((a, b) {
       return a.nameInfo.id - b.nameInfo.id;
     });
     elementRelations.sort((a, b) {
       return a.elementInfo.id - b.elementInfo.id;
     });
     nameRelations.sort((a, b) {
       return a.nameInfo.id - b.nameInfo.id;
     });
     return new UnitIndexBuilder(
         unit: unitId,
         definedNames: definedNames.map((n) => n.nameInfo.id).toList(),
         definedNameKinds: definedNames.map((n) => n.kind).toList(),
         definedNameOffsets: definedNames.map((n) => n.offset).toList(),
         usedElements: elementRelations.map((r) => r.elementInfo.id).toList(),
         usedElementKinds: elementRelations.map((r) => r.kind).toList(),
         usedElementOffsets: elementRelations.map((r) => r.offset).toList(),
         usedElementLengths: elementRelations.map((r) => r.length).toList(),
         usedElementIsQualifiedFlags:
             elementRelations.map((r) => r.isQualified).toList(),
         usedNames: nameRelations.map((r) => r.nameInfo.id).toList(),
         usedNameKinds: nameRelations.map((r) => r.kind).toList(),
-        usedNameOffsets: nameRelations.map((r) => r.offset).toList());
+        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));
   }
 }