New analyzer snapshot.

pkg/analyzer/lib/src/generated/index.dart

 // Copyright (c) 2014, 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.
 
 // This code was auto-generated, is not intended to be edited, and is subject to
 // significant change. Please see the README file for more information.
 
 library engine.index;
 
 import 'dart:collection' show Queue;
@@ skipping 1194 matching lines @@
    * The relationship used to indicate that an element (the left-operand) is invoked at a specific
    * location (the right operand). This is used for methods.
    */
   static final Relationship IS_INVOKED_BY_QUALIFIED = Relationship.getRelationship("is-invoked-by-qualified");
 
   /**
    * The relationship used to indicate that an element (the left-operand) is invoked at a specific
    * location (the right operand). This is used for methods.
    */
   static final Relationship IS_INVOKED_BY_UNQUALIFIED = Relationship.getRelationship("is-invoked-by-unqualified");
+
+  /**
+   * Reference to some [AngularElement].
+   */
+  static final Relationship ANGULAR_REFERENCE = Relationship.getRelationship("angular-reference");
+
+  /**
+   * Reference to some closing tag of an XML element.
+   */
+  static final Relationship ANGULAR_CLOSING_TAG_REFERENCE = Relationship.getRelationship("angular-closing-tag-reference");
 }
 
 /**
  * Visits resolved [HtmlUnit] and adds relationships into [IndexStore].
  *
  * @coverage dart.engine.index
  */
 class AngularHtmlIndexContributor extends ExpressionVisitor {
   /**
    * The [IndexStore] to record relations into.
@@ skipping 16 matching lines @@
     this._store = store;
     _indexContributor = new IndexContributor_AngularHtmlIndexContributor(store, this);
   }
 
   void visitExpression(Expression expression) {
     // NgFilter
     if (expression is SimpleIdentifier) {
       SimpleIdentifier identifier = expression;
       Element element = identifier.bestElement;
       if (element is AngularElement) {
-        _store.recordRelationship(element, IndexConstants.IS_REFERENCED_BY, createLocation(identifier));
+        _store.recordRelationship(element, IndexConstants.ANGULAR_REFERENCE, createLocation(identifier));
         return;
       }
     }
     // index as a normal Dart expression
     expression.accept(_indexContributor);
   }
 
   Object visitHtmlUnit(ht.HtmlUnit node) {
     _htmlUnitElement = node.element;
     CompilationUnitElement dartUnitElement = _htmlUnitElement.angularCompilationUnit;
     _indexContributor.enterScope(dartUnitElement);
     return super.visitHtmlUnit(node);
   }
 
   Object visitXmlAttributeNode(ht.XmlAttributeNode node) {
     Element element = node.element;
     if (element != null) {
       ht.Token nameToken = node.nameToken;
       Location location = createLocation2(nameToken);
-      _store.recordRelationship(element, IndexConstants.IS_REFERENCED_BY, location);
+      _store.recordRelationship(element, IndexConstants.ANGULAR_REFERENCE, location);
     }
     return super.visitXmlAttributeNode(node);
   }
 
   Object visitXmlTagNode(ht.XmlTagNode node) {
     Element element = node.element;
     if (element != null) {
-      ht.Token tagToken = node.tagToken;
-      Location location = createLocation2(tagToken);
-      _store.recordRelationship(element, IndexConstants.IS_REFERENCED_BY, location);
+      // tag
+      {
+        ht.Token tagToken = node.tagToken;
+        Location location = createLocation2(tagToken);
+        _store.recordRelationship(element, IndexConstants.ANGULAR_REFERENCE, location);
+      }
+      // maybe add closing tag range
+      ht.Token closingTag = node.closingTag;
+      if (closingTag != null) {
+        Location location = createLocation2(closingTag);
+        _store.recordRelationship(element, IndexConstants.ANGULAR_CLOSING_TAG_REFERENCE, location);
+      }
     }
     return super.visitXmlTagNode(node);
   }
 
   Location createLocation(SimpleIdentifier identifier) => new Location(_htmlUnitElement, identifier.offset, identifier.length);
 
   Location createLocation2(ht.Token token) => new Location(_htmlUnitElement, token.offset, token.length);
 }
 
 class IndexContributor_AngularHtmlIndexContributor extends IndexContributor {
   final AngularHtmlIndexContributor AngularHtmlIndexContributor_this;
 
   IndexContributor_AngularHtmlIndexContributor(IndexStore arg0, this.AngularHtmlIndexContributor_this) : super(arg0);
 
   Element peekElement() => AngularHtmlIndexContributor_this._htmlUnitElement;
 
   void recordRelationship(Element element, Relationship relationship, Location location) {
     AngularElement angularElement = AngularHtmlUnitResolver.getAngularElement(element);
     if (angularElement != null) {
       element = angularElement;
-      relationship = IndexConstants.IS_REFERENCED_BY;
+      relationship = IndexConstants.ANGULAR_REFERENCE;
     }
     super.recordRelationship(element, relationship, location);
   }
 }
 
 /**
  * The interface [Index] defines the behavior of objects that maintain an index storing
  * [Relationship] between [Element]. All of the operations
  * defined on the index are asynchronous, and results, when there are any, are provided through a
  * callback.
@@ skipping 244 matching lines @@
   static IndexContributor_ImportElementInfo getImportElementInfo(SimpleIdentifier prefixNode) {
     IndexContributor_ImportElementInfo info = new IndexContributor_ImportElementInfo();
     // prepare environment
     ASTNode parent = prefixNode.parent;
     CompilationUnit unit = prefixNode.getAncestor(CompilationUnit);
     LibraryElement libraryElement = unit.element.library;
     // prepare used element
     Element usedElement = null;
     if (parent is PrefixedIdentifier) {
       PrefixedIdentifier prefixed = parent;
-      usedElement = prefixed.staticElement;
-      info._periodEnd = prefixed.period.end;
+      if (identical(prefixed.prefix, prefixNode)) {
+        usedElement = prefixed.staticElement;
+        info._periodEnd = prefixed.period.end;
+      }
     }
     if (parent is MethodInvocation) {
       MethodInvocation invocation = parent;
-      usedElement = invocation.methodName.staticElement;
-      info._periodEnd = invocation.period.end;
+      if (identical(invocation.target, prefixNode)) {
+        usedElement = invocation.methodName.staticElement;
+        info._periodEnd = invocation.period.end;
+      }
     }
     // we need used Element
     if (usedElement == null) {
       return null;
     }
     // find ImportElement
     String prefix = prefixNode.name;
     Map<ImportElement, Set<Element>> importElementsMap = {};
     info._element = getImportElement2(libraryElement, prefix, usedElement, importElementsMap);
     if (info._element == null) {
@@ skipping 150 matching lines @@
     if (parent is AssignmentExpression) {
       AssignmentExpression assignment = parent as AssignmentExpression;
       Expression rhs = assignment.rightHandSide;
       location = getLocationWithExpressionType(location, rhs);
     }
     // done
     return location;
   }
 
   /**
+   * @return `true` if given "node" is part of an import [Combinator].
+   */
+  static bool isIdentifierInImportCombinator(SimpleIdentifier node) {
+    ASTNode parent = node.parent;
+    return parent is Combinator;
+  }
+
+  /**
    * @return `true` if given "node" is part of [PrefixedIdentifier] "prefix.node".
    */
   static bool isIdentifierInPrefixedIdentifier(SimpleIdentifier node) {
     ASTNode parent = node.parent;
     return parent is PrefixedIdentifier && identical(parent.identifier, node);
   }
 
   /**
    * @return `true` if given [SimpleIdentifier] is "name" part of prefixed identifier or
    *         method invocation.
@@ skipping 162 matching lines @@
     enterScope(element);
     try {
       return super.visitConstructorDeclaration(node);
     } finally {
       exitScope();
     }
   }
 
   Object visitConstructorName(ConstructorName node) {
     ConstructorElement element = node.staticElement;
+    // in 'class B = A;' actually A constructors are invoked
+    if (element != null && element.isSynthetic && element.redirectedConstructor != null) {
+      element = element.redirectedConstructor;
+    }
+    // prepare location
     Location location;
     if (node.name != null) {
       int start = node.period.offset;
       int end = node.name.end;
       location = createLocation4(start, end - start);
     } else {
       int start = node.type.end;
       location = createLocation4(start, 0);
     }
+    // record relationship
     recordRelationship(element, IndexConstants.IS_REFERENCED_BY, location);
     return super.visitConstructorName(node);
   }
 
   Object visitExportDirective(ExportDirective node) {
     ExportElement element = node.element as ExportElement;
     if (element != null) {
       LibraryElement expLibrary = element.exportedLibrary;
       recordLibraryReference(node, expLibrary);
     }
@@ skipping 288 matching lines @@
     Location location = createLocation(element);
     recordRelationship(_libraryElement, relationship, location);
     recordRelationship(IndexConstants.UNIVERSE, relationship, location);
   }
 
   /**
    * Records [ImportElement] reference if given [SimpleIdentifier] references some
    * top-level element and not qualified with import prefix.
    */
   void recordImportElementReferenceWithoutPrefix(SimpleIdentifier node) {
+    if (isIdentifierInImportCombinator(node)) {
+      return;
+    }
     if (isIdentifierInPrefixedIdentifier(node)) {
       return;
     }
     Element element = node.staticElement;
     ImportElement importElement = getImportElement2(_libraryElement, null, element, _importElementsMap);
     if (importElement != null) {
       Location location = createLocation4(node.offset, 0);
       recordRelationship(importElement, IndexConstants.IS_REFERENCED_BY, location);
     }
   }
@@ skipping 299 matching lines @@
   Object visitCompilationUnitMember(CompilationUnitMember node) => null;
 
   void indexComponent(AngularComponentElement component) {
     indexProperties(component.properties);
   }
 
   void indexDirective(AngularDirectiveElement directive) {
     indexProperties(directive.properties);
   }
 
+  /**
+   * Index [FieldElement] references from [AngularPropertyElement]s.
+   */
   void indexProperties(List<AngularPropertyElement> properties) {
     for (AngularPropertyElement property in properties) {
       FieldElement field = property.field;
       if (field != null) {
         int offset = property.fieldNameOffset;
+        if (offset == -1) {
+          continue;
+        }
         int length = field.name.length;
         Location location = new Location(property, offset, length);
         // getter reference
         if (property.propertyKind.callsGetter()) {
           PropertyAccessorElement getter = field.getter;
           if (getter != null) {
             _store.recordRelationship(getter, IndexConstants.IS_REFERENCED_BY_QUALIFIED, location);
           }
         }
         // setter reference
@@ skipping 245 matching lines @@
    * element are available. For example, if the element is a field and the relationship is the
    * is-referenced-by relationship, then this method will be invoked with each location at which the
    * field is referenced.
    *
    * @param element the [Element] that has the relationship with the locations
    * @param relationship the relationship between the given element and the locations
    * @param locations the locations that were found
    */
   void hasRelationships(Element element, Relationship relationship, List<Location> locations);
 }