New analzyer 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 1218 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.ANGULAR_REFERENCE, createLocation(identifier));
+        _store.recordRelationship(element, IndexConstants.ANGULAR_REFERENCE, createLocationForIdentifier(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);
+      Location location = createLocationForToken(nameToken);
       _store.recordRelationship(element, IndexConstants.ANGULAR_REFERENCE, location);
     }
     return super.visitXmlAttributeNode(node);
   }
 
   Object visitXmlTagNode(ht.XmlTagNode node) {
     Element element = node.element;
     if (element != null) {
       // tag
       {
         ht.Token tagToken = node.tagToken;
-        Location location = createLocation2(tagToken);
+        Location location = createLocationForToken(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);
+        Location location = createLocationForToken(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 createLocationForIdentifier(SimpleIdentifier identifier) => new Location(_htmlUnitElement, identifier.offset, identifier.length);
 
-  Location createLocation2(ht.Token token) => new Location(_htmlUnitElement, token.offset, token.length);
+  Location createLocationForToken(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) {
@@ skipping 244 matching lines @@
   }
 
   /**
    * @return the [ImportElementInfo] with [ImportElement] that is referenced by this
    *         node with [PrefixElement], may be `null`.
    */
   static IndexContributor_ImportElementInfo getImportElementInfo(SimpleIdentifier prefixNode) {
     IndexContributor_ImportElementInfo info = new IndexContributor_ImportElementInfo();
     // prepare environment
     AstNode parent = prefixNode.parent;
-    CompilationUnit unit = prefixNode.getAncestor(CompilationUnit);
+    CompilationUnit unit = prefixNode.getAncestor((node) => node is CompilationUnit);
     LibraryElement libraryElement = unit.element.library;
     // prepare used element
     Element usedElement = null;
     if (parent is PrefixedIdentifier) {
       PrefixedIdentifier prefixed = parent;
       if (identical(prefixed.prefix, prefixNode)) {
         usedElement = prefixed.staticElement;
         info._periodEnd = prefixed.period.end;
       }
     }
@@ skipping 259 matching lines @@
       recordElementDefinition(element, IndexConstants.DEFINES_CLASS);
       {
         ExtendsClause extendsClause = node.extendsClause;
         if (extendsClause != null) {
           TypeName superclassNode = extendsClause.superclass;
           recordSuperType(superclassNode, IndexConstants.IS_EXTENDED_BY);
         } else {
           InterfaceType superType = element.supertype;
           if (superType != null) {
             ClassElement objectElement = superType.element;
-            recordRelationship(objectElement, IndexConstants.IS_EXTENDED_BY, createLocation4(node.name.offset, 0));
+            recordRelationship(objectElement, IndexConstants.IS_EXTENDED_BY, createLocationFromOffset(node.name.offset, 0));
           }
         }
       }
       {
         WithClause withClause = node.withClause;
         if (withClause != null) {
           for (TypeName mixinNode in withClause.mixinTypes) {
             recordSuperType(mixinNode, IndexConstants.IS_MIXED_IN_BY);
           }
         }
@@ skipping 58 matching lines @@
   }
 
   Object visitConstructorDeclaration(ConstructorDeclaration node) {
     ConstructorElement element = node.element;
     // define
     {
       Location location;
       if (node.name != null) {
         int start = node.period.offset;
         int end = node.name.end;
-        location = createLocation4(start, end - start);
+        location = createLocationFromOffset(start, end - start);
       } else {
         int start = node.returnType.end;
-        location = createLocation4(start, 0);
+        location = createLocationFromOffset(start, 0);
       }
       recordRelationship(element, IndexConstants.IS_DEFINED_BY, location);
     }
     // visit children
     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);
+      location = createLocationFromOffset(start, end - start);
     } else {
       int start = node.type.end;
-      location = createLocation4(start, 0);
+      location = createLocationFromOffset(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;
@@ skipping 35 matching lines @@
       LibraryElement impLibrary = element.importedLibrary;
       recordLibraryReference(node, impLibrary);
     }
     return super.visitImportDirective(node);
   }
 
   Object visitIndexExpression(IndexExpression node) {
     MethodElement element = node.bestElement;
     if (element is MethodElement) {
       Token operator = node.leftBracket;
-      Location location = createLocation5(operator);
+      Location location = createLocationFromToken(operator);
       recordRelationship(element, IndexConstants.IS_INVOKED_BY_QUALIFIED, location);
     }
     return super.visitIndexExpression(node);
   }
 
   Object visitMethodDeclaration(MethodDeclaration node) {
     ExecutableElement element = node.element;
     enterScope(element);
     try {
       return super.visitMethodDeclaration(node);
     } finally {
       exitScope();
     }
   }
 
   Object visitMethodInvocation(MethodInvocation node) {
     SimpleIdentifier name = node.methodName;
     Element element = name.bestElement;
     if (element is MethodElement) {
-      Location location = createLocation3(name);
+      Location location = createLocationFromNode(name);
       Relationship relationship;
       if (node.target != null) {
         relationship = IndexConstants.IS_INVOKED_BY_QUALIFIED;
       } else {
         relationship = IndexConstants.IS_INVOKED_BY_UNQUALIFIED;
       }
       recordRelationship(element, relationship, location);
     }
     if (element is FunctionElement) {
-      Location location = createLocation3(name);
+      Location location = createLocationFromNode(name);
       recordRelationship(element, IndexConstants.IS_INVOKED_BY, location);
     }
     recordImportElementReferenceWithoutPrefix(name);
     return super.visitMethodInvocation(node);
   }
 
   Object visitPartDirective(PartDirective node) {
     Element element = node.element;
-    Location location = createLocation3(node.uri);
+    Location location = createLocationFromNode(node.uri);
     recordRelationship(element, IndexConstants.IS_REFERENCED_BY, location);
     return super.visitPartDirective(node);
   }
 
   Object visitPartOfDirective(PartOfDirective node) {
-    Location location = createLocation3(node.libraryName);
+    Location location = createLocationFromNode(node.libraryName);
     recordRelationship(node.element, IndexConstants.IS_REFERENCED_BY, location);
     return null;
   }
 
   Object visitPostfixExpression(PostfixExpression node) {
     recordOperatorReference(node.operator, node.bestElement);
     return super.visitPostfixExpression(node);
   }
 
   Object visitPrefixExpression(PrefixExpression node) {
     recordOperatorReference(node.operator, node.bestElement);
     return super.visitPrefixExpression(node);
   }
 
   Object visitSimpleIdentifier(SimpleIdentifier node) {
     Element nameElement = new NameElementImpl(node.name);
-    Location location = createLocation3(node);
+    Location location = createLocationFromNode(node);
     // name in declaration
     if (node.inDeclarationContext()) {
       recordRelationship(nameElement, IndexConstants.IS_DEFINED_BY, location);
       return null;
     }
     // prepare information
     Element element = node.bestElement;
     // qualified name reference
     recordQualifiedMemberReference(node, element, nameElement, location);
     // stop if already handled
@@ skipping 35 matching lines @@
     recordImportElementReferenceWithoutPrefix(node);
     return super.visitSimpleIdentifier(node);
   }
 
   Object visitSuperConstructorInvocation(SuperConstructorInvocation node) {
     ConstructorElement element = node.staticElement;
     Location location;
     if (node.constructorName != null) {
       int start = node.period.offset;
       int end = node.constructorName.end;
-      location = createLocation4(start, end - start);
+      location = createLocationFromOffset(start, end - start);
     } else {
       int start = node.keyword.end;
-      location = createLocation4(start, 0);
+      location = createLocationFromOffset(start, 0);
     }
     recordRelationship(element, IndexConstants.IS_REFERENCED_BY, location);
     return super.visitSuperConstructorInvocation(node);
   }
 
   Object visitTopLevelVariableDeclaration(TopLevelVariableDeclaration node) {
     VariableDeclarationList variables = node.variables;
     for (VariableDeclaration variableDeclaration in variables.variables) {
       Element element = variableDeclaration.element;
       recordElementDefinition(element, IndexConstants.DEFINES_VARIABLE);
     }
     return super.visitTopLevelVariableDeclaration(node);
   }
 
   Object visitTypeParameter(TypeParameter node) {
     TypeParameterElement element = node.element;
     enterScope(element);
     try {
       return super.visitTypeParameter(node);
     } finally {
       exitScope();
     }
   }
 
   Object visitVariableDeclaration(VariableDeclaration node) {
     VariableElement element = node.element;
     // record declaration
     {
       SimpleIdentifier name = node.name;
-      Location location = createLocation3(name);
+      Location location = createLocationFromNode(name);
       location = getLocationWithExpressionType(location, node.initializer);
       recordRelationship(element, IndexConstants.IS_DEFINED_BY, location);
     }
     // visit
     enterScope(element);
     try {
       return super.visitVariableDeclaration(node);
     } finally {
       exitScope();
     }
@@ skipping 29 matching lines @@
    */
   void recordRelationship(Element element, Relationship relationship, Location location) {
     if (element != null && location != null) {
       _store.recordRelationship(element, relationship, location);
     }
   }
 
   /**
    * @return the [Location] representing location of the [AstNode].
    */
-  Location createLocation3(AstNode node) => createLocation4(node.offset, node.length);
+  Location createLocationFromNode(AstNode node) => createLocationFromOffset(node.offset, node.length);
 
   /**
    * @param offset the offset of the location within [Source]
    * @param length the length of the location
    * @return the [Location] representing the given offset and length within the inner-most
    *         [Element].
    */
-  Location createLocation4(int offset, int length) {
+  Location createLocationFromOffset(int offset, int length) {
     Element element = peekElement();
     return new Location(element, offset, length);
   }
 
   /**
    * @return the [Location] representing location of the [Token].
    */
-  Location createLocation5(Token token) => createLocation4(token.offset, token.length);
+  Location createLocationFromToken(Token token) => createLocationFromOffset(token.offset, token.length);
 
   /**
    * Exit the current scope.
    */
   void exitScope() {
     _elementStack.removeFirst();
   }
 
   /**
    * @return `true` if given node already indexed as more interesting reference, so it should
@@ skipping 26 matching lines @@
   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);
+      Location location = createLocationFromOffset(node.offset, 0);
       recordRelationship(importElement, IndexConstants.IS_REFERENCED_BY, location);
     }
   }
 
   /**
    * Records [ImportElement] that declares given prefix and imports library with element used
    * with given prefix node.
    */
   void recordImportElementReferenceWithPrefix(SimpleIdentifier prefixNode) {
     IndexContributor_ImportElementInfo info = getImportElementInfo(prefixNode);
     if (info != null) {
       int offset = prefixNode.offset;
       int length = info._periodEnd - offset;
-      Location location = createLocation4(offset, length);
+      Location location = createLocationFromOffset(offset, length);
       recordRelationship(info._element, IndexConstants.IS_REFERENCED_BY, location);
     }
   }
 
   /**
    * Records reference to defining [CompilationUnitElement] of the given
    * [LibraryElement].
    */
   void recordLibraryReference(UriBasedDirective node, LibraryElement library) {
     if (library != null) {
-      Location location = createLocation3(node.uri);
+      Location location = createLocationFromNode(node.uri);
       recordRelationship(library.definingCompilationUnit, IndexConstants.IS_REFERENCED_BY, location);
     }
   }
 
   /**
    * Record reference to the given operator [Element] and name.
    */
   void recordOperatorReference(Token operator, Element element) {
     // prepare location
-    Location location = createLocation5(operator);
+    Location location = createLocationFromToken(operator);
     // record name reference
     {
       String name = operator.lexeme;
       if (name == "++") {
         name = "+";
       }
       if (name == "--") {
         name = "-";
       }
       if (StringUtilities.endsWithChar(name, 0x3D) && name != "==") {
@@ skipping 22 matching lines @@
 
   /**
    * Records extends/implements relationships between given [ClassElement] and [Type] of
    * "superNode".
    */
   void recordSuperType(TypeName superNode, Relationship relationship) {
     if (superNode != null) {
       Identifier superName = superNode.name;
       if (superName != null) {
         Element superElement = superName.staticElement;
-        recordRelationship(superElement, relationship, createLocation3(superNode));
+        recordRelationship(superElement, relationship, createLocationFromNode(superNode));
       }
     }
   }
 }
 
 /**
  * Information about [ImportElement] and place where it is referenced using
  * [PrefixElement].
  */
 class IndexContributor_ImportElementInfo {
@@ skipping 470 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);
 }