Translate private Java members to private Dart members.

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 93 matching lines @@
   static AnalysisContext unwrapContext(AnalysisContext context) {
     if (context is InstrumentedAnalysisContextImpl) {
       context = (context as InstrumentedAnalysisContextImpl).basis;
     }
     return context;
   }
 
   /**
    * @return the [Source] of the enclosing [LibraryElement], may be `null`.
    */
-  static Source getLibrarySourceOrNull(Element element) {
+  static Source _getLibrarySourceOrNull(Element element) {
     LibraryElement library = element.library;
     if (library == null) {
       return null;
     }
     if (library.isAngularHtml) {
       return null;
     }
     return library.source;
   }
 
@@ skipping 39 matching lines @@
 
   int _sourceCount = 0;
 
   int _keyCount = 0;
 
   int _locationCount = 0;
 
   bool aboutToIndexDart(AnalysisContext context, CompilationUnitElement unitElement) {
     context = unwrapContext(context);
     // may be already removed in other thread
-    if (isRemovedContext(context)) {
+    if (_isRemovedContext(context)) {
       return false;
     }
     // validate unit
     if (unitElement == null) {
       return false;
     }
     LibraryElement libraryElement = unitElement.library;
     if (libraryElement == null) {
       return false;
     }
@@ skipping 15 matching lines @@
       Map<Source, Set<Source>> libraryToUnits = _contextToLibraryToUnits[context];
       if (libraryToUnits == null) {
         libraryToUnits = {};
         _contextToLibraryToUnits[context] = libraryToUnits;
       }
       Set<Source> oldParts = libraryToUnits[library];
       // check if some parts are not in the library now
       if (oldParts != null) {
         Set<Source> noParts = oldParts.difference(newParts);
         for (Source noPart in noParts) {
-          removeLocations(context, library, noPart);
+          _removeLocations(context, library, noPart);
         }
       }
       // remember new parts
       libraryToUnits[library] = newParts;
     }
     // remember libraries in which unit is used
-    recordUnitInLibrary(context, library, unit);
+    _recordUnitInLibrary(context, library, unit);
     // remove locations
-    removeLocations(context, library, unit);
+    _removeLocations(context, library, unit);
     // remove keys
     {
       Map<MemoryIndexStoreImpl_Source2, Set<MemoryIndexStoreImpl_ElementRelationKey>> sourceToKeys = _contextToSourceToKeys[context];
       if (sourceToKeys != null) {
         MemoryIndexStoreImpl_Source2 source2 = new MemoryIndexStoreImpl_Source2(library, unit);
         bool hadSource = sourceToKeys.remove(source2) != null;
         if (hadSource) {
           _sourceCount--;
         }
       }
     }
     // OK, we can index
     return true;
   }
 
   bool aboutToIndexHtml(AnalysisContext context, HtmlElement htmlElement) {
     context = unwrapContext(context);
     // may be already removed in other thread
-    if (isRemovedContext(context)) {
+    if (_isRemovedContext(context)) {
       return false;
     }
     // remove locations
     Source source = htmlElement.source;
-    removeLocations(context, null, source);
+    _removeLocations(context, null, source);
     // remove keys
     {
       Map<MemoryIndexStoreImpl_Source2, Set<MemoryIndexStoreImpl_ElementRelationKey>> sourceToKeys = _contextToSourceToKeys[context];
       if (sourceToKeys != null) {
         MemoryIndexStoreImpl_Source2 source2 = new MemoryIndexStoreImpl_Source2(null, source);
         bool hadSource = sourceToKeys.remove(source2) != null;
         if (hadSource) {
           _sourceCount--;
         }
       }
     }
     // remember libraries in which unit is used
-    recordUnitInLibrary(context, null, source);
+    _recordUnitInLibrary(context, null, source);
     // OK, we can index
     return true;
   }
 
   List<Location> getRelationships(Element element, Relationship relationship) {
     MemoryIndexStoreImpl_ElementRelationKey key = new MemoryIndexStoreImpl_ElementRelationKey(element, relationship);
     Set<Location> locations = _keyToLocations[key];
     if (locations != null) {
       return new List.from(locations);
     }
@@ skipping 44 matching lines @@
     // at the index level we don't care about Member(s)
     if (element is Member) {
       element = (element as Member).baseElement;
     }
     //    System.out.println(element + " " + relationship + " " + location);
     // prepare information
     AnalysisContext elementContext = element.context;
     AnalysisContext locationContext = location.element.context;
     Source elementSource = element.source;
     Source locationSource = location.element.source;
-    Source elementLibrarySource = getLibrarySourceOrNull(element);
-    Source locationLibrarySource = getLibrarySourceOrNull(location.element);
+    Source elementLibrarySource = _getLibrarySourceOrNull(element);
+    Source locationLibrarySource = _getLibrarySourceOrNull(location.element);
     // sanity check
     if (locationContext == null) {
       return;
     }
     if (locationSource == null) {
       return;
     }
     if (elementContext == null && element is! NameElementImpl && element is! UniverseElementImpl) {
       return;
     }
     if (elementSource == null && element is! NameElementImpl && element is! UniverseElementImpl) {
       return;
     }
     // may be already removed in other thread
-    if (isRemovedContext(elementContext)) {
+    if (_isRemovedContext(elementContext)) {
       return;
     }
-    if (isRemovedContext(locationContext)) {
+    if (_isRemovedContext(locationContext)) {
       return;
     }
     // record: key -> location(s)
-    MemoryIndexStoreImpl_ElementRelationKey key = getCanonicalKey(element, relationship);
+    MemoryIndexStoreImpl_ElementRelationKey key = _getCanonicalKey(element, relationship);
     {
       Set<Location> locations = _keyToLocations.remove(key);
       if (locations == null) {
-        locations = createLocationIdentitySet();
+        locations = _createLocationIdentitySet();
       } else {
         _keyCount--;
       }
       _keyToLocations[key] = locations;
       _keyCount++;
       locations.add(location);
       _locationCount++;
     }
     // record: location -> key
     location.internalKey = key;
@@ skipping 31 matching lines @@
       locations.add(location);
     }
   }
 
   void removeContext(AnalysisContext context) {
     context = unwrapContext(context);
     if (context == null) {
       return;
     }
     // mark as removed
-    markRemovedContext(context);
+    _markRemovedContext(context);
     removeSources(context, null);
     // remove context
     _contextToSourceToKeys.remove(context);
     _contextToSourceToLocations.remove(context);
     _contextToLibraryToUnits.remove(context);
     _contextToUnitToLibraries.remove(context);
   }
 
   void removeSource(AnalysisContext context, Source unit) {
     context = unwrapContext(context);
     if (context == null) {
       return;
     }
     // remove locations defined in source
     Map<Source, Set<Source>> unitToLibraries = _contextToUnitToLibraries[context];
     if (unitToLibraries != null) {
       Set<Source> libraries = unitToLibraries.remove(unit);
       if (libraries != null) {
         for (Source library in libraries) {
           MemoryIndexStoreImpl_Source2 source2 = new MemoryIndexStoreImpl_Source2(library, unit);
           // remove locations defined in source
-          removeLocations(context, library, unit);
+          _removeLocations(context, library, unit);
           // remove keys for elements defined in source
           Map<MemoryIndexStoreImpl_Source2, Set<MemoryIndexStoreImpl_ElementRelationKey>> sourceToKeys = _contextToSourceToKeys[context];
           if (sourceToKeys != null) {
             Set<MemoryIndexStoreImpl_ElementRelationKey> keys = sourceToKeys.remove(source2);
             if (keys != null) {
               for (MemoryIndexStoreImpl_ElementRelationKey key in keys) {
                 _canonicalKeys.remove(key);
                 Set<Location> locations = _keyToLocations.remove(key);
                 if (locations != null) {
                   _keyCount--;
@@ skipping 33 matching lines @@
         if (container == null || container.contains(source)) {
           removeSource(context, source);
         }
       }
     }
   }
 
   /**
    * Creates new [Set] that uses object identity instead of equals.
    */
-  Set<Location> createLocationIdentitySet() => new Set<Location>.identity();
+  Set<Location> _createLocationIdentitySet() => new Set<Location>.identity();
 
   /**
    * @return the canonical [ElementRelationKey] for given [Element] and
    *         [Relationship], i.e. unique instance for this combination.
    */
-  MemoryIndexStoreImpl_ElementRelationKey getCanonicalKey(Element element, Relationship relationship) {
+  MemoryIndexStoreImpl_ElementRelationKey _getCanonicalKey(Element element, Relationship relationship) {
     MemoryIndexStoreImpl_ElementRelationKey key = new MemoryIndexStoreImpl_ElementRelationKey(element, relationship);
     MemoryIndexStoreImpl_ElementRelationKey canonicalKey = _canonicalKeys[key];
     if (canonicalKey == null) {
       canonicalKey = key;
       _canonicalKeys[key] = canonicalKey;
     }
     return canonicalKey;
   }
 
   /**
    * Checks if given [AnalysisContext] is marked as removed.
    */
-  bool isRemovedContext(AnalysisContext context) => _removedContexts[context] != null;
+  bool _isRemovedContext(AnalysisContext context) => _removedContexts[context] != null;
 
   /**
    * Marks given [AnalysisContext] as removed.
    */
-  void markRemovedContext(AnalysisContext context) {
+  void _markRemovedContext(AnalysisContext context) {
     _removedContexts[context] = true;
   }
 
-  void recordUnitInLibrary(AnalysisContext context, Source library, Source unit) {
+  void _recordUnitInLibrary(AnalysisContext context, Source library, Source unit) {
     Map<Source, Set<Source>> unitToLibraries = _contextToUnitToLibraries[context];
     if (unitToLibraries == null) {
       unitToLibraries = {};
       _contextToUnitToLibraries[context] = unitToLibraries;
     }
     Set<Source> libraries = unitToLibraries[unit];
     if (libraries == null) {
       libraries = new Set();
       unitToLibraries[unit] = libraries;
     }
     libraries.add(library);
   }
 
   /**
    * Removes locations recorded in the given library/unit pair.
    */
-  void removeLocations(AnalysisContext context, Source library, Source unit) {
+  void _removeLocations(AnalysisContext context, Source library, Source unit) {
     MemoryIndexStoreImpl_Source2 source2 = new MemoryIndexStoreImpl_Source2(library, unit);
     Map<MemoryIndexStoreImpl_Source2, List<Location>> sourceToLocations = _contextToSourceToLocations[context];
     if (sourceToLocations != null) {
       List<Location> sourceLocations = sourceToLocations.remove(source2);
       if (sourceLocations != null) {
         for (Location location in sourceLocations) {
           MemoryIndexStoreImpl_ElementRelationKey key = location.internalKey as MemoryIndexStoreImpl_ElementRelationKey;
           Set<Location> relLocations = _keyToLocations[key];
           if (relLocations != null) {
             relLocations.remove(location);
@@ skipping 137 matching lines @@
  */
 abstract class ExpressionVisitor extends ht.RecursiveXmlVisitor<Object> {
   /**
    * Visits the given [Expression]s embedded into tag or attribute.
    *
    * @param expression the [Expression] to visit, not `null`
    */
   void visitExpression(Expression expression);
 
   Object visitXmlAttributeNode(ht.XmlAttributeNode node) {
-    visitExpressions(node.expressions);
+    _visitExpressions(node.expressions);
     return super.visitXmlAttributeNode(node);
   }
 
   Object visitXmlTagNode(ht.XmlTagNode node) {
-    visitExpressions(node.expressions);
+    _visitExpressions(node.expressions);
     return super.visitXmlTagNode(node);
   }
 
   /**
    * Visits [Expression]s of the given [XmlExpression]s.
    */
-  void visitExpressions(List<ht.XmlExpression> expressions) {
+  void _visitExpressions(List<ht.XmlExpression> expressions) {
     for (ht.XmlExpression xmlExpression in expressions) {
       if (xmlExpression is AngularXmlExpression) {
         AngularXmlExpression angularXmlExpression = xmlExpression;
         List<Expression> dartExpressions = angularXmlExpression.expression.expressions;
         for (Expression dartExpression in dartExpressions) {
           visitExpression(dartExpression);
         }
       }
       if (xmlExpression is ht.RawXmlExpression) {
         ht.RawXmlExpression rawXmlExpression = xmlExpression;
@@ skipping 254 matching lines @@
       return unanalyzedSources;
     } else if (identical(_state, ProcessorState.STOPPED)) {
       return unanalyzedSources;
     } else if (identical(_state, ProcessorState.RUNNING)) {
       _state = ProcessorState.STOP_REQESTED;
     }
     while (wait) {
       if (identical(_state, ProcessorState.STOPPED)) {
         return unanalyzedSources;
       }
-      waitOneMs();
+      _waitOneMs();
     }
     return unanalyzedSources;
   }
 
   /**
    * Waits until processors will switch from "ready" to "running" state.
    *
    * @return `true` if processor is now actually in "running" state, e.g. not in "stopped"
    *         state.
    */
   bool waitForRunning() {
     while (identical(_state, ProcessorState.READY)) {
-      threadYield();
+      _threadYield();
     }
     return identical(_state, ProcessorState.RUNNING);
   }
 
   /**
    * @return the [Source]s that are not indexed yet.
    */
   List<Source> get unanalyzedSources {
     Set<Source> sources = new Set();
     for (IndexOperation operation in _queue.operations) {
       if (operation is IndexUnitOperation) {
         Source source = operation.source;
         sources.add(source);
       }
     }
     return new List.from(sources);
   }
 
   /**
    * Return `true` if the current state is [ProcessorState#RUNNING].
    *
    * @return `true` if this processor is running
    */
   bool get isRunning => identical(_state, ProcessorState.RUNNING);
 
-  void threadYield() {
+  void _threadYield() {
   }
 
-  void waitOneMs() {
+  void _waitOneMs() {
   }
 }
 
 /**
  * The enumeration <code>ProcessorState</code> represents the possible states of an operation
  * processor.
  */
 class ProcessorState extends Enum<ProcessorState> {
   /**
    * The processor is ready to be run (has not been run before).
@@ skipping 190 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, createLocationForIdentifier(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 = createLocationForToken(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 = createLocationForToken(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 = createLocationForToken(closingTag);
+        Location location = _createLocationForToken(closingTag);
         _store.recordRelationship(element, IndexConstants.ANGULAR_CLOSING_TAG_REFERENCE, location);
       }
     }
     return super.visitXmlTagNode(node);
   }
 
-  Location createLocationForIdentifier(SimpleIdentifier identifier) => new Location(_htmlUnitElement, identifier.offset, identifier.length);
+  Location _createLocationForIdentifier(SimpleIdentifier identifier) => new Location(_htmlUnitElement, identifier.offset, identifier.length);
 
-  Location createLocationForToken(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 269 matching lines @@
         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 = internalGetImportElement(libraryElement, prefix, usedElement, importElementsMap);
+    info._element = _internalGetImportElement(libraryElement, prefix, usedElement, importElementsMap);
     if (info._element == null) {
       return null;
     }
     return info;
   }
 
   /**
    * If the given expression has resolved type, returns the new location with this type.
    *
    * @param location the base location
    * @param expression the expression assigned at the given location
    */
-  static Location getLocationWithExpressionType(Location location, Expression expression) {
+  static Location _getLocationWithExpressionType(Location location, Expression expression) {
     if (expression != null) {
       return new LocationWithData<Type2>.con1(location, expression.bestType);
     }
     return location;
   }
 
   /**
    * If the given node is the part of the [ConstructorFieldInitializer], returns location with
    * type of the initializer expression.
    */
-  static Location getLocationWithInitializerType(SimpleIdentifier node, Location location) {
+  static Location _getLocationWithInitializerType(SimpleIdentifier node, Location location) {
     if (node.parent is ConstructorFieldInitializer) {
       ConstructorFieldInitializer initializer = node.parent as ConstructorFieldInitializer;
       if (identical(initializer.fieldName, node)) {
-        location = getLocationWithExpressionType(location, initializer.expression);
+        location = _getLocationWithExpressionType(location, initializer.expression);
       }
     }
     return location;
   }
 
   /**
    * If the given identifier has a synthetic [PropertyAccessorElement], i.e. accessor for
    * normal field, and it is LHS of assignment, then include [Type] of the assigned value into
    * the [Location].
    *
    * @param identifier the identifier to record location
    * @param element the element of the identifier
    * @param location the raw location
    * @return the [Location] with the type of the assigned value
    */
-  static Location getLocationWithTypeAssignedToField(SimpleIdentifier identifier, Element element, Location location) {
+  static Location _getLocationWithTypeAssignedToField(SimpleIdentifier identifier, Element element, Location location) {
     // we need accessor
     if (element is! PropertyAccessorElement) {
       return location;
     }
     PropertyAccessorElement accessor = element as PropertyAccessorElement;
     // should be setter
     if (!accessor.isSetter) {
       return location;
     }
     // accessor should be synthetic, i.e. field normal
@@ skipping 19 matching lines @@
         if (identical(prefixedIdentifier.identifier, node)) {
           node = prefixedIdentifier;
           parent = prefixedIdentifier.parent;
         }
       }
     }
     // OK, remember the type
     if (parent is AssignmentExpression) {
       AssignmentExpression assignment = parent as AssignmentExpression;
       Expression rhs = assignment.rightHandSide;
-      location = getLocationWithExpressionType(location, rhs);
+      location = _getLocationWithExpressionType(location, rhs);
     }
     // done
     return location;
   }
 
   /**
    * @return the [ImportElement] that declares given [PrefixElement] and imports library
    *         with given "usedElement".
    */
-  static ImportElement internalGetImportElement(LibraryElement libraryElement, String prefix, Element usedElement, Map<ImportElement, Set<Element>> importElementsMap) {
+  static ImportElement _internalGetImportElement(LibraryElement libraryElement, String prefix, Element usedElement, Map<ImportElement, Set<Element>> importElementsMap) {
     // validate Element
     if (usedElement == null) {
       return null;
     }
     if (usedElement.enclosingElement is! CompilationUnitElement) {
       return null;
     }
     LibraryElement usedLibrary = usedElement.library;
     // find ImportElement that imports used library with used prefix
     List<ImportElement> candidates = null;
@@ skipping 49 matching lines @@
         return entry.getKey();
       }
     }
     // not found
     return null;
   }
 
   /**
    * @return `true` if given "node" is part of an import [Combinator].
    */
-  static bool isIdentifierInImportCombinator(SimpleIdentifier node) {
+  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) {
+  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.
    */
-  static bool isQualified(SimpleIdentifier node) {
+  static bool _isQualified(SimpleIdentifier node) {
     AstNode parent = node.parent;
     if (parent is PrefixedIdentifier) {
       return identical(parent.identifier, node);
     }
     if (parent is PropertyAccess) {
       return identical(parent.propertyName, node);
     }
     if (parent is MethodInvocation) {
       MethodInvocation invocation = parent;
       return invocation.realTarget != null && identical(invocation.methodName, node);
@@ skipping 30 matching lines @@
   Element peekElement() {
     for (Element element in _elementStack) {
       if (element != null) {
         return element;
       }
     }
     return null;
   }
 
   Object visitAssignmentExpression(AssignmentExpression node) {
-    recordOperatorReference(node.operator, node.bestElement);
+    _recordOperatorReference(node.operator, node.bestElement);
     return super.visitAssignmentExpression(node);
   }
 
   Object visitBinaryExpression(BinaryExpression node) {
-    recordOperatorReference(node.operator, node.bestElement);
+    _recordOperatorReference(node.operator, node.bestElement);
     return super.visitBinaryExpression(node);
   }
 
   Object visitClassDeclaration(ClassDeclaration node) {
     ClassElement element = node.element;
     enterScope(element);
     try {
-      recordElementDefinition(element, IndexConstants.DEFINES_CLASS);
+      _recordElementDefinition(element, IndexConstants.DEFINES_CLASS);
       {
         ExtendsClause extendsClause = node.extendsClause;
         if (extendsClause != null) {
           TypeName superclassNode = extendsClause.superclass;
-          recordSuperType(superclassNode, IndexConstants.IS_EXTENDED_BY);
+          _recordSuperType(superclassNode, IndexConstants.IS_EXTENDED_BY);
         } else {
           InterfaceType superType = element.supertype;
           if (superType != null) {
             ClassElement objectElement = superType.element;
-            recordRelationship(objectElement, IndexConstants.IS_EXTENDED_BY, createLocationFromOffset(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);
+            _recordSuperType(mixinNode, IndexConstants.IS_MIXED_IN_BY);
           }
         }
       }
       {
         ImplementsClause implementsClause = node.implementsClause;
         if (implementsClause != null) {
           for (TypeName interfaceNode in implementsClause.interfaces) {
-            recordSuperType(interfaceNode, IndexConstants.IS_IMPLEMENTED_BY);
+            _recordSuperType(interfaceNode, IndexConstants.IS_IMPLEMENTED_BY);
           }
         }
       }
       return super.visitClassDeclaration(node);
     } finally {
-      exitScope();
+      _exitScope();
     }
   }
 
   Object visitClassTypeAlias(ClassTypeAlias node) {
     ClassElement element = node.element;
     enterScope(element);
     try {
-      recordElementDefinition(element, IndexConstants.DEFINES_CLASS_ALIAS);
+      _recordElementDefinition(element, IndexConstants.DEFINES_CLASS_ALIAS);
       {
         TypeName superclassNode = node.superclass;
         if (superclassNode != null) {
-          recordSuperType(superclassNode, IndexConstants.IS_EXTENDED_BY);
+          _recordSuperType(superclassNode, IndexConstants.IS_EXTENDED_BY);
         }
       }
       {
         WithClause withClause = node.withClause;
         if (withClause != null) {
           for (TypeName mixinNode in withClause.mixinTypes) {
-            recordSuperType(mixinNode, IndexConstants.IS_MIXED_IN_BY);
+            _recordSuperType(mixinNode, IndexConstants.IS_MIXED_IN_BY);
           }
         }
       }
       {
         ImplementsClause implementsClause = node.implementsClause;
         if (implementsClause != null) {
           for (TypeName interfaceNode in implementsClause.interfaces) {
-            recordSuperType(interfaceNode, IndexConstants.IS_IMPLEMENTED_BY);
+            _recordSuperType(interfaceNode, IndexConstants.IS_IMPLEMENTED_BY);
           }
         }
       }
       return super.visitClassTypeAlias(node);
     } finally {
-      exitScope();
+      _exitScope();
     }
   }
 
   Object visitCompilationUnit(CompilationUnit node) {
     CompilationUnitElement unitElement = node.element;
     if (unitElement != null) {
       _elementStack.add(unitElement);
       _libraryElement = unitElement.enclosingElement;
       if (_libraryElement != null) {
         return super.visitCompilationUnit(node);
       }
     }
     return null;
   }
 
   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 = createLocationFromOffset(start, end - start);
+        location = _createLocationFromOffset(start, end - start);
       } else {
         int start = node.returnType.end;
-        location = createLocationFromOffset(start, 0);
+        location = _createLocationFromOffset(start, 0);
       }
       recordRelationship(element, IndexConstants.IS_DEFINED_BY, location);
     }
     // visit children
     enterScope(element);
     try {
       return super.visitConstructorDeclaration(node);
     } finally {
-      exitScope();
+      _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 = createLocationFromOffset(start, end - start);
+      location = _createLocationFromOffset(start, end - start);
     } else {
       int start = node.type.end;
-      location = createLocationFromOffset(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;
     if (element != null) {
       LibraryElement expLibrary = element.exportedLibrary;
-      recordLibraryReference(node, expLibrary);
+      _recordLibraryReference(node, expLibrary);
     }
     return super.visitExportDirective(node);
   }
 
   Object visitFormalParameter(FormalParameter node) {
     ParameterElement element = node.element;
     enterScope(element);
     try {
       return super.visitFormalParameter(node);
     } finally {
-      exitScope();
+      _exitScope();
     }
   }
 
   Object visitFunctionDeclaration(FunctionDeclaration node) {
     Element element = node.element;
-    recordElementDefinition(element, IndexConstants.DEFINES_FUNCTION);
+    _recordElementDefinition(element, IndexConstants.DEFINES_FUNCTION);
     enterScope(element);
     try {
       return super.visitFunctionDeclaration(node);
     } finally {
-      exitScope();
+      _exitScope();
     }
   }
 
   Object visitFunctionTypeAlias(FunctionTypeAlias node) {
     Element element = node.element;
-    recordElementDefinition(element, IndexConstants.DEFINES_FUNCTION_TYPE);
+    _recordElementDefinition(element, IndexConstants.DEFINES_FUNCTION_TYPE);
     return super.visitFunctionTypeAlias(node);
   }
 
   Object visitImportDirective(ImportDirective node) {
     ImportElement element = node.element;
     if (element != null) {
       LibraryElement impLibrary = element.importedLibrary;
-      recordLibraryReference(node, impLibrary);
+      _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 = createLocationFromToken(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();
+      _exitScope();
     }
   }
 
   Object visitMethodInvocation(MethodInvocation node) {
     SimpleIdentifier name = node.methodName;
     Element element = name.bestElement;
     if (element is MethodElement) {
-      Location location = createLocationFromNode(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 = createLocationFromNode(name);
+      Location location = _createLocationFromNode(name);
       recordRelationship(element, IndexConstants.IS_INVOKED_BY, location);
     }
-    recordImportElementReferenceWithoutPrefix(name);
+    _recordImportElementReferenceWithoutPrefix(name);
     return super.visitMethodInvocation(node);
   }
 
   Object visitPartDirective(PartDirective node) {
     Element element = node.element;
-    Location location = createLocationFromNode(node.uri);
+    Location location = _createLocationFromNode(node.uri);
     recordRelationship(element, IndexConstants.IS_REFERENCED_BY, location);
     return super.visitPartDirective(node);
   }
 
   Object visitPartOfDirective(PartOfDirective node) {
-    Location location = createLocationFromNode(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);
+    _recordOperatorReference(node.operator, node.bestElement);
     return super.visitPostfixExpression(node);
   }
 
   Object visitPrefixExpression(PrefixExpression node) {
-    recordOperatorReference(node.operator, node.bestElement);
+    _recordOperatorReference(node.operator, node.bestElement);
     return super.visitPrefixExpression(node);
   }
 
   Object visitSimpleIdentifier(SimpleIdentifier node) {
     Element nameElement = new NameElementImpl(node.name);
-    Location location = createLocationFromNode(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);
+    _recordQualifiedMemberReference(node, element, nameElement, location);
     // stop if already handled
-    if (isAlreadyHandledName(node)) {
+    if (_isAlreadyHandledName(node)) {
       return null;
     }
     // record specific relations
     if (element is ClassElement || element is FunctionElement || element is FunctionTypeAliasElement || element is LabelElement || element is TypeParameterElement) {
       recordRelationship(element, IndexConstants.IS_REFERENCED_BY, location);
     } else if (element is FieldElement) {
-      location = getLocationWithInitializerType(node, location);
+      location = _getLocationWithInitializerType(node, location);
       recordRelationship(element, IndexConstants.IS_REFERENCED_BY, location);
     } else if (element is FieldFormalParameterElement) {
       FieldFormalParameterElement fieldParameter = element;
       FieldElement field = fieldParameter.field;
       recordRelationship(field, IndexConstants.IS_REFERENCED_BY_QUALIFIED, location);
     } else if (element is PrefixElement) {
-      recordImportElementReferenceWithPrefix(node);
+      _recordImportElementReferenceWithPrefix(node);
     } else if (element is PropertyAccessorElement || element is MethodElement) {
-      location = getLocationWithTypeAssignedToField(node, element, location);
-      if (isQualified(node)) {
+      location = _getLocationWithTypeAssignedToField(node, element, location);
+      if (_isQualified(node)) {
         recordRelationship(element, IndexConstants.IS_REFERENCED_BY_QUALIFIED, location);
       } else {
         recordRelationship(element, IndexConstants.IS_REFERENCED_BY_UNQUALIFIED, location);
       }
     } else if (element is ParameterElement || element is LocalVariableElement) {
       bool inGetterContext = node.inGetterContext();
       bool inSetterContext = node.inSetterContext();
       if (inGetterContext && inSetterContext) {
         recordRelationship(element, IndexConstants.IS_READ_WRITTEN_BY, location);
       } else if (inGetterContext) {
         recordRelationship(element, IndexConstants.IS_READ_BY, location);
       } else if (inSetterContext) {
         recordRelationship(element, IndexConstants.IS_WRITTEN_BY, location);
       } else {
         recordRelationship(element, IndexConstants.IS_REFERENCED_BY, location);
       }
     }
-    recordImportElementReferenceWithoutPrefix(node);
+    _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 = createLocationFromOffset(start, end - start);
+      location = _createLocationFromOffset(start, end - start);
     } else {
       int start = node.keyword.end;
-      location = createLocationFromOffset(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);
+      _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();
+      _exitScope();
     }
   }
 
   Object visitVariableDeclaration(VariableDeclaration node) {
     VariableElement element = node.element;
     // record declaration
     {
       SimpleIdentifier name = node.name;
-      Location location = createLocationFromNode(name);
-      location = getLocationWithExpressionType(location, node.initializer);
+      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();
+      _exitScope();
     }
   }
 
   Object visitVariableDeclarationList(VariableDeclarationList node) {
     NodeList<VariableDeclaration> variables = node.variables;
     if (variables != null) {
       // use first VariableDeclaration as Element for Location(s) in type
       {
         TypeName type = node.type;
         if (type != null) {
           for (VariableDeclaration variableDeclaration in variables) {
             enterScope(variableDeclaration.element);
             try {
               type.accept(this);
             } finally {
-              exitScope();
+              _exitScope();
             }
             // only one iteration
             break;
           }
         }
       }
       // visit variables
       variables.accept(this);
     }
     return null;
   }
 
   /**
    * Record the given relationship between the given [Element] and [Location].
    */
   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 createLocationFromNode(AstNode node) => createLocationFromOffset(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 createLocationFromOffset(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 createLocationFromToken(Token token) => createLocationFromOffset(token.offset, token.length);
+  Location _createLocationFromToken(Token token) => _createLocationFromOffset(token.offset, token.length);
 
   /**
    * Exit the current scope.
    */
-  void exitScope() {
+  void _exitScope() {
     _elementStack.removeFirst();
   }
 
   /**
    * @return `true` if given node already indexed as more interesting reference, so it should
    *         not be indexed again.
    */
-  bool isAlreadyHandledName(SimpleIdentifier node) {
+  bool _isAlreadyHandledName(SimpleIdentifier node) {
     AstNode parent = node.parent;
     if (parent is MethodInvocation) {
       Element element = node.staticElement;
       if (element is MethodElement || element is FunctionElement) {
         return identical(parent.methodName, node);
       }
     }
     return false;
   }
 
   /**
    * Records the [Element] definition in the library and universe.
    */
-  void recordElementDefinition(Element element, Relationship relationship) {
+  void _recordElementDefinition(Element element, Relationship relationship) {
     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)) {
+  void _recordImportElementReferenceWithoutPrefix(SimpleIdentifier node) {
+    if (_isIdentifierInImportCombinator(node)) {
       return;
     }
-    if (isIdentifierInPrefixedIdentifier(node)) {
+    if (_isIdentifierInPrefixedIdentifier(node)) {
       return;
     }
     Element element = node.staticElement;
-    ImportElement importElement = internalGetImportElement(_libraryElement, null, element, _importElementsMap);
+    ImportElement importElement = _internalGetImportElement(_libraryElement, null, element, _importElementsMap);
     if (importElement != null) {
-      Location location = createLocationFromOffset(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) {
+  void _recordImportElementReferenceWithPrefix(SimpleIdentifier prefixNode) {
     IndexContributor_ImportElementInfo info = getImportElementInfo(prefixNode);
     if (info != null) {
       int offset = prefixNode.offset;
       int length = info._periodEnd - offset;
-      Location location = createLocationFromOffset(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) {
+  void _recordLibraryReference(UriBasedDirective node, LibraryElement library) {
     if (library != null) {
-      Location location = createLocationFromNode(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) {
+  void _recordOperatorReference(Token operator, Element element) {
     // prepare location
-    Location location = createLocationFromToken(operator);
+    Location location = _createLocationFromToken(operator);
     // record name reference
     {
       String name = operator.lexeme;
       if (name == "++") {
         name = "+";
       }
       if (name == "--") {
         name = "-";
       }
       if (StringUtilities.endsWithChar(name, 0x3D) && name != "==") {
         name = name.substring(0, name.length - 1);
       }
       Element nameElement = new NameElementImpl(name);
       Relationship relationship = element != null ? IndexConstants.IS_REFERENCED_BY_QUALIFIED_RESOLVED : IndexConstants.IS_REFERENCED_BY_QUALIFIED_UNRESOLVED;
       recordRelationship(nameElement, relationship, location);
     }
     // record element reference
     if (element != null) {
       recordRelationship(element, IndexConstants.IS_INVOKED_BY_QUALIFIED, location);
     }
   }
 
   /**
    * Records reference if the given [SimpleIdentifier] looks like a qualified property access
    * or method invocation.
    */
-  void recordQualifiedMemberReference(SimpleIdentifier node, Element element, Element nameElement, Location location) {
-    if (isQualified(node)) {
+  void _recordQualifiedMemberReference(SimpleIdentifier node, Element element, Element nameElement, Location location) {
+    if (_isQualified(node)) {
       Relationship relationship = element != null ? IndexConstants.IS_REFERENCED_BY_QUALIFIED_RESOLVED : IndexConstants.IS_REFERENCED_BY_QUALIFIED_UNRESOLVED;
       recordRelationship(nameElement, relationship, location);
     }
   }
 
   /**
    * Records extends/implements relationships between given [ClassElement] and [Type] of
    * "superNode".
    */
-  void recordSuperType(TypeName superNode, Relationship relationship) {
+  void _recordSuperType(TypeName superNode, Relationship relationship) {
     if (superNode != null) {
       Identifier superName = superNode.name;
       if (superName != null) {
         Element superElement = superName.staticElement;
-        recordRelationship(superElement, relationship, createLocationFromNode(superNode));
+        recordRelationship(superElement, relationship, _createLocationFromNode(superNode));
       }
     }
   }
 }
 
 /**
  * Information about [ImportElement] and place where it is referenced using
  * [PrefixElement].
  */
 class IndexContributor_ImportElementInfo {
@@ skipping 62 matching lines @@
    *          before giving up and returning `null`
    * @return the operation that was removed from the queue
    * @throws InterruptedException if the thread on which this method is running was interrupted
    *           while it was waiting for an operation to be added to the queue
    */
   IndexOperation dequeue(int timeout) {
     if (_nonQueryOperations.isEmpty && (!_processQueries || _queryOperations.isEmpty)) {
       if (timeout <= 0) {
         return null;
       }
-      waitForOperationAvailable(timeout);
+      _waitForOperationAvailable(timeout);
     }
     if (!_nonQueryOperations.isEmpty) {
       return _nonQueryOperations.removeFirst();
     }
     if (_processQueries && !_queryOperations.isEmpty) {
       return _queryOperations.removeFirst();
     }
     return null;
   }
 
   /**
    * Add the given operation to the tail of this queue.
    *
    * @param operation the operation to be added to the queue
    */
   void enqueue(IndexOperation operation) {
     if (operation is RemoveSourceOperation) {
       Source source = operation.source;
-      removeForSource(source, _nonQueryOperations);
-      removeForSource(source, _queryOperations);
+      _removeForSource(source, _nonQueryOperations);
+      _removeForSource(source, _queryOperations);
     }
     if (operation.isQuery) {
       _queryOperations.add(operation);
     } else {
       _nonQueryOperations.add(operation);
     }
-    notifyOperationAvailable();
+    _notifyOperationAvailable();
   }
 
   /**
    * Return a list containing all of the operations that are currently on the queue. Modifying this
    * list will not affect the state of the queue.
    *
    * @return all of the operations that are currently on the queue
    */
   List<IndexOperation> get operations {
     List<IndexOperation> operations = [];
     operations.addAll(_nonQueryOperations);
     operations.addAll(_queryOperations);
     return operations;
   }
 
   /**
    * Set whether the receiver's [dequeue] method should return query operations.
    *
    * @param processQueries `true` if the receiver's [dequeue] method should
    *          return query operations or `false` if query operations should be queued but not
    *          returned by the receiver's [dequeue] method until this method is called
    *          with a value of `true`.
    */
   void set processQueries(bool processQueries) {
     if (this._processQueries != processQueries) {
       this._processQueries = processQueries;
       if (processQueries && !_queryOperations.isEmpty) {
-        notifyOperationAvailable();
+        _notifyOperationAvailable();
       }
     }
   }
 
   /**
    * Return the number of operations on the queue.
    *
    * @return the number of operations on the queue
    */
   int size() => _nonQueryOperations.length + _queryOperations.length;
 
-  void notifyOperationAvailable() {
+  void _notifyOperationAvailable() {
   }
 
   /**
    * Removes operations that should be removed when given [Source] is removed.
    */
-  void removeForSource(Source source, Queue<IndexOperation> operations) {
+  void _removeForSource(Source source, Queue<IndexOperation> operations) {
     operations.removeWhere((_) => _.removeWhenSourceRemoved(source));
   }
 
-  void waitForOperationAvailable(int timeout) {
+  void _waitForOperationAvailable(int timeout) {
   }
 }
 
 /**
  * Special [Element] which is used to index references to the name without specifying concrete
  * kind of this name - field, method or something else.
  */
 class NameElementImpl extends ElementImpl {
   NameElementImpl(String name) : super.con2("name:${name}", -1);
 
@@ skipping 12 matching lines @@
   AngularDartIndexContributor(IndexStore store) {
     this._store = store;
   }
 
   Object visitClassDeclaration(ClassDeclaration node) {
     ClassElement classElement = node.element;
     if (classElement != null) {
       List<ToolkitObjectElement> toolkitObjects = classElement.toolkitObjects;
       for (ToolkitObjectElement object in toolkitObjects) {
         if (object is AngularComponentElement) {
-          indexComponent(object);
+          _indexComponent(object);
         }
         if (object is AngularDirectiveElement) {
           AngularDirectiveElement directive = object;
-          indexDirective(directive);
+          _indexDirective(directive);
         }
       }
     }
     // stop visiting
     return null;
   }
 
   Object visitCompilationUnitMember(CompilationUnitMember node) => null;
 
-  void indexComponent(AngularComponentElement component) {
-    indexProperties(component.properties);
+  void _indexComponent(AngularComponentElement component) {
+    _indexProperties(component.properties);
   }
 
-  void indexDirective(AngularDirectiveElement directive) {
-    indexProperties(directive.properties);
+  void _indexDirective(AngularDirectiveElement directive) {
+    _indexProperties(directive.properties);
   }
 
   /**
    * Index [FieldElement] references from [AngularPropertyElement]s.
    */
-  void indexProperties(List<AngularPropertyElement> properties) {
+  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
@@ skipping 234 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);
 }