/*
* Copyright (c) 2013, the Dart project authors.
*
* Licensed under the Eclipse Public License v1.0 (the "License"); you may not use this file except
* in compliance with the License. You may obtain a copy of the License at
*
* http://www.eclipse.org/legal/epl-v10.html
*
* Unless required by applicable law or agreed to in writing, software distributed under the License
* is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
* or implied. See the License for the specific language governing permissions and limitations under
* the License.
*/
package com.google.dart.engine.internal.search;
import com.google.common.collect.Lists;
import com.google.common.collect.Sets;
import com.google.common.util.concurrent.Uninterruptibles;
import com.google.dart.engine.element.ClassElement;
import com.google.dart.engine.element.CompilationUnitElement;
import com.google.dart.engine.element.ConstructorElement;
import com.google.dart.engine.element.Element;
import com.google.dart.engine.element.FunctionElement;
import com.google.dart.engine.element.FunctionTypeAliasElement;
import com.google.dart.engine.element.ImportElement;
import com.google.dart.engine.element.LibraryElement;
import com.google.dart.engine.element.LocalVariableElement;
import com.google.dart.engine.element.MethodElement;
import com.google.dart.engine.element.ParameterElement;
import com.google.dart.engine.element.PropertyAccessorElement;
import com.google.dart.engine.element.PropertyInducingElement;
import com.google.dart.engine.element.TypeParameterElement;
import com.google.dart.engine.element.VariableElement;
import com.google.dart.engine.element.angular.AngularElement;
import com.google.dart.engine.index.Index;
import com.google.dart.engine.index.Location;
import com.google.dart.engine.index.LocationWithData;
import com.google.dart.engine.index.Relationship;
import com.google.dart.engine.index.RelationshipCallback;
import com.google.dart.engine.internal.element.member.Member;
import com.google.dart.engine.internal.index.IndexConstants;
import com.google.dart.engine.internal.index.NameElementImpl;
import com.google.dart.engine.internal.search.listener.CountingSearchListener;
import com.google.dart.engine.internal.search.listener.FilteredSearchListener;
import com.google.dart.engine.internal.search.listener.GatheringSearchListener;
import com.google.dart.engine.internal.search.listener.NameMatchingSearchListener;
import com.google.dart.engine.internal.search.scope.LibrarySearchScope;
import com.google.dart.engine.search.MatchKind;
import com.google.dart.engine.search.MatchQuality;
import com.google.dart.engine.search.SearchEngine;
import com.google.dart.engine.search.SearchFilter;
import com.google.dart.engine.search.SearchListener;
import com.google.dart.engine.search.SearchMatch;
import com.google.dart.engine.search.SearchPattern;
import com.google.dart.engine.search.SearchScope;
import com.google.dart.engine.type.Type;
import com.google.dart.engine.utilities.source.SourceRange;
import java.util.Collections;
import java.util.List;
import java.util.Set;
import java.util.concurrent.CountDownLatch;
/**
* Implementation of {@link SearchEngine}.
*
* @coverage dart.engine.search
*/
public class SearchEngineImpl implements SearchEngine {
/**
* Instances of the class <code>RelationshipCallbackImpl</code> implement a callback that can be
* used to report results to a search listener.
*/
private static class RelationshipCallbackImpl implements RelationshipCallback {
private final SearchScope scope;
/**
* The kind of matches that are represented by the results that will be provided to this
* callback.
*/
private MatchKind matchKind;
/**
* The search listener that should be notified when results are found.
*/
private SearchListener listener;
/**
* Initialize a newly created callback to report matches of the given kind to the given listener
* when results are found.
*
* @param scope the {@link SearchScope} to return matches from, may be {@code null} to return
* all matches
* @param matchKind the kind of matches that are represented by the results
* @param listener the search listener that should be notified when results are found
*/
public RelationshipCallbackImpl(SearchScope scope, MatchKind matchKind, SearchListener listener) {
this.scope = scope;
this.matchKind = matchKind;
this.listener = listener;
}
@Override
public void hasRelationships(Element element, Relationship relationship, Location[] locations) {
for (Location location : locations) {
Element targetElement = location.getElement();
// check scope
if (scope != null && !scope.encloses(targetElement)) {
continue;
}
SourceRange range = new SourceRange(location.getOffset(), location.getLength());
// TODO(scheglov) IndexConstants.DYNAMIC for MatchQuality.NAME
MatchQuality quality = MatchQuality.EXACT;
// MatchQuality quality = element.getResource() != IndexConstants.DYNAMIC
// ? MatchQuality.EXACT : MatchQuality.NAME;
SearchMatch match = new SearchMatch(quality, matchKind, targetElement, range);
match.setQualified(relationship == IndexConstants.IS_REFERENCED_BY_QUALIFIED
|| relationship == IndexConstants.IS_INVOKED_BY_QUALIFIED);
listener.matchFound(match);
}
listener.searchComplete();
}
}
/**
* The interface <code>SearchRunner</code> defines the behavior of objects that can be used to
* perform an asynchronous search.
*/
private interface SearchRunner {
/**
* Perform an asynchronous search, passing the results to the given listener.
*
* @param listener the listener to which search results should be passed @ if the results could
* not be computed
*/
public void performSearch(SearchListener listener);
}
/**
* Apply the given filter to the given listener.
*
* @param filter the filter to be used before passing matches on to the listener, or {@code null}
* if all matches should be passed on
* @param listener the listener that will only be given matches that pass the filter
* @return a search listener that will pass to the given listener any matches that pass the given
* filter
*/
private static SearchListener applyFilter(SearchFilter filter, SearchListener listener) {
if (filter == null) {
return listener;
}
return new FilteredSearchListener(filter, listener);
}
/**
* Apply the given pattern to the given listener.
*
* @param pattern the pattern to be used before passing matches on to the listener, or
* {@code null} if all matches should be passed on
* @param listener the listener that will only be given matches that match the pattern
* @return a search listener that will pass to the given listener any matches that match the given
* pattern
*/
private static SearchListener applyPattern(SearchPattern pattern, SearchListener listener) {
if (pattern == null) {
return listener;
}
return new NameMatchingSearchListener(pattern, listener);
}
private static Element[] createElements(SearchScope scope) {
if (scope instanceof LibrarySearchScope) {
return ((LibrarySearchScope) scope).getLibraries();
}
return new Element[] {IndexConstants.UNIVERSE};
}
private static RelationshipCallback newCallback(MatchKind matchKind, SearchScope scope,
SearchListener listener) {
return new RelationshipCallbackImpl(scope, matchKind, listener);
}
/**
* The index used to respond to the search requests.
*/
private Index index;
/**
* Initialize a newly created search engine to use the given index.
*
* @param index the index used to respond to the search requests
*/
public SearchEngineImpl(Index index) {
this.index = index;
}
@Override
public Set<Type> searchAssignedTypes(PropertyInducingElement variable, SearchScope scope) {
PropertyAccessorElement setter = variable.getSetter();
int numRequests = (setter != null ? 2 : 0) + 2;
// find locations
final List<Location> locations = Lists.newArrayList();
final CountDownLatch latch = new CountDownLatch(numRequests);
class Callback implements RelationshipCallback {
@Override
public void hasRelationships(Element element, Relationship relationship, Location[] locs) {
Collections.addAll(locations, locs);
latch.countDown();
}
}
if (setter != null) {
index.getRelationships(setter, IndexConstants.IS_REFERENCED_BY_QUALIFIED, new Callback());
index.getRelationships(setter, IndexConstants.IS_REFERENCED_BY_UNQUALIFIED, new Callback());
}
index.getRelationships(variable, IndexConstants.IS_REFERENCED_BY, new Callback());
index.getRelationships(variable, IndexConstants.IS_DEFINED_BY, new Callback());
Uninterruptibles.awaitUninterruptibly(latch);
// get types from locations
Set<Type> types = Sets.newHashSet();
for (Location location : locations) {
// check scope
if (scope != null) {
Element targetElement = location.getElement();
if (!scope.encloses(targetElement)) {
continue;
}
}
// we need data
if (!(location instanceof LocationWithData<?>)) {
continue;
}
LocationWithData<?> locationWithData = (LocationWithData<?>) location;
// add type
Object data = locationWithData.getData();
if (data instanceof Type) {
Type type = (Type) data;
types.add(type);
}
}
// done
return types;
}
@Override
public List<SearchMatch> searchDeclarations(final String name, final SearchScope scope,
final SearchFilter filter) {
return gatherResults(new SearchRunner() {
@Override
public void performSearch(SearchListener listener) {
searchDeclarations(name, scope, filter, listener);
}
});
}
@Override
public void searchDeclarations(String name, SearchScope scope, SearchFilter filter,
SearchListener listener) {
assert listener != null;
listener = applyFilter(filter, listener);
index.getRelationships(
new NameElementImpl(name),
IndexConstants.IS_DEFINED_BY,
newCallback(MatchKind.NAME_DECLARATION, scope, listener));
}
@Override
public List<SearchMatch> searchFunctionDeclarations(final SearchScope scope,
final SearchPattern pattern, final SearchFilter filter) {
return gatherResults(new SearchRunner() {
@Override
public void performSearch(SearchListener listener) {
searchFunctionDeclarations(scope, pattern, filter, listener);
}
});
}
@Override
public void searchFunctionDeclarations(SearchScope scope, SearchPattern pattern,
SearchFilter filter, SearchListener listener) {
assert listener != null;
Element[] elements = createElements(scope);
listener = applyPattern(pattern, listener);
listener = applyFilter(filter, listener);
listener = new CountingSearchListener(elements.length, listener);
for (Element element : elements) {
index.getRelationships(
element,
IndexConstants.DEFINES_FUNCTION,
newCallback(MatchKind.FUNCTION_DECLARATION, scope, listener));
}
}
@Override
public List<SearchMatch> searchQualifiedMemberReferences(final String name,
final SearchScope scope, final SearchFilter filter) {
return gatherResults(new SearchRunner() {
@Override
public void performSearch(SearchListener listener) {
searchQualifiedMemberReferences(name, scope, filter, listener);
}
});
}
@Override
public void searchQualifiedMemberReferences(String name, SearchScope scope, SearchFilter filter,
SearchListener listener) {
assert listener != null;
listener = applyFilter(filter, listener);
listener = new CountingSearchListener(10, listener);
index.getRelationships(
new NameElementImpl(name),
IndexConstants.IS_REFERENCED_BY_QUALIFIED_RESOLVED,
newCallback(MatchKind.NAME_REFERENCE_RESOLVED, scope, listener));
index.getRelationships(
new NameElementImpl(name),
IndexConstants.IS_REFERENCED_BY_QUALIFIED_UNRESOLVED,
newCallback(MatchKind.NAME_REFERENCE_UNRESOLVED, scope, listener));
// granular resolved operations
index.getRelationships(
new NameElementImpl(name),
IndexConstants.NAME_IS_INVOKED_BY_RESOLVED,
newCallback(MatchKind.NAME_INVOCATION_RESOLVED, scope, listener));
index.getRelationships(
new NameElementImpl(name),
IndexConstants.NAME_IS_READ_BY_RESOLVED,
newCallback(MatchKind.NAME_READ_RESOLVED, scope, listener));
index.getRelationships(
new NameElementImpl(name),
IndexConstants.NAME_IS_READ_WRITTEN_BY_RESOLVED,
newCallback(MatchKind.NAME_READ_WRITE_RESOLVED, scope, listener));
index.getRelationships(
new NameElementImpl(name),
IndexConstants.NAME_IS_WRITTEN_BY_RESOLVED,
newCallback(MatchKind.NAME_WRITE_RESOLVED, scope, listener));
// granular unresolved operations
index.getRelationships(
new NameElementImpl(name),
IndexConstants.NAME_IS_INVOKED_BY_UNRESOLVED,
newCallback(MatchKind.NAME_INVOCATION_UNRESOLVED, scope, listener));
index.getRelationships(
new NameElementImpl(name),
IndexConstants.NAME_IS_READ_BY_UNRESOLVED,
newCallback(MatchKind.NAME_READ_UNRESOLVED, scope, listener));
index.getRelationships(
new NameElementImpl(name),
IndexConstants.NAME_IS_READ_WRITTEN_BY_UNRESOLVED,
newCallback(MatchKind.NAME_READ_WRITE_UNRESOLVED, scope, listener));
index.getRelationships(
new NameElementImpl(name),
IndexConstants.NAME_IS_WRITTEN_BY_UNRESOLVED,
newCallback(MatchKind.NAME_WRITE_UNRESOLVED, scope, listener));
}
@Override
public List<SearchMatch> searchReferences(final Element element, final SearchScope scope,
final SearchFilter filter) {
return gatherResults(new SearchRunner() {
@Override
public void performSearch(SearchListener listener) {
searchReferences(element, scope, filter, listener);
}
});
}
@Override
public void searchReferences(Element element, SearchScope scope, SearchFilter filter,
SearchListener listener) {
if (element == null) {
listener.searchComplete();
return;
}
if (element instanceof Member) {
element = ((Member) element).getBaseElement();
}
switch (element.getKind()) {
case ANGULAR_COMPONENT:
case ANGULAR_CONTROLLER:
case ANGULAR_FORMATTER:
case ANGULAR_PROPERTY:
case ANGULAR_SCOPE_PROPERTY:
case ANGULAR_SELECTOR:
searchReferences((AngularElement) element, scope, filter, listener);
return;
case CLASS:
searchReferences((ClassElement) element, scope, filter, listener);
return;
case COMPILATION_UNIT:
searchReferences((CompilationUnitElement) element, scope, filter, listener);
return;
case CONSTRUCTOR:
searchReferences((ConstructorElement) element, scope, filter, listener);
return;
case FIELD:
case TOP_LEVEL_VARIABLE:
searchReferences((PropertyInducingElement) element, scope, filter, listener);
return;
case FUNCTION:
searchReferences((FunctionElement) element, scope, filter, listener);
return;
case GETTER:
case SETTER:
searchReferences((PropertyAccessorElement) element, scope, filter, listener);
return;
case IMPORT:
searchReferences((ImportElement) element, scope, filter, listener);
return;
case LIBRARY:
searchReferences((LibraryElement) element, scope, filter, listener);
return;
case LOCAL_VARIABLE:
searchReferences((LocalVariableElement) element, scope, filter, listener);
return;
case METHOD:
searchReferences((MethodElement) element, scope, filter, listener);
return;
case PARAMETER:
searchReferences((ParameterElement) element, scope, filter, listener);
return;
case FUNCTION_TYPE_ALIAS:
searchReferences((FunctionTypeAliasElement) element, scope, filter, listener);
return;
case TYPE_PARAMETER:
searchReferences((TypeParameterElement) element, scope, filter, listener);
return;
default:
listener.searchComplete();
return;
}
}
@Override
public List<SearchMatch> searchSubtypes(final ClassElement type, final SearchScope scope,
final SearchFilter filter) {
return gatherResults(new SearchRunner() {
@Override
public void performSearch(SearchListener listener) {
searchSubtypes(type, scope, filter, listener);
}
});
}
@Override
public void searchSubtypes(ClassElement type, SearchScope scope, SearchFilter filter,
SearchListener listener) {
assert listener != null;
listener = applyFilter(filter, listener);
listener = new CountingSearchListener(3, listener);
index.getRelationships(
type,
IndexConstants.IS_EXTENDED_BY,
newCallback(MatchKind.EXTENDS_REFERENCE, scope, listener));
index.getRelationships(
type,
IndexConstants.IS_MIXED_IN_BY,
newCallback(MatchKind.WITH_REFERENCE, scope, listener));
index.getRelationships(
type,
IndexConstants.IS_IMPLEMENTED_BY,
newCallback(MatchKind.IMPLEMENTS_REFERENCE, scope, listener));
}
@Override
public List<SearchMatch> searchTypeDeclarations(final SearchScope scope,
final SearchPattern pattern, final SearchFilter filter) {
return gatherResults(new SearchRunner() {
@Override
public void performSearch(SearchListener listener) {
searchTypeDeclarations(scope, pattern, filter, listener);
}
});
}
@Override
public void searchTypeDeclarations(SearchScope scope, SearchPattern pattern, SearchFilter filter,
SearchListener listener) {
assert listener != null;
Element[] elements = createElements(scope);
listener = applyPattern(pattern, listener);
listener = applyFilter(filter, listener);
listener = new CountingSearchListener(elements.length * 3, listener);
for (Element element : elements) {
index.getRelationships(
element,
IndexConstants.DEFINES_CLASS,
newCallback(MatchKind.CLASS_DECLARATION, scope, listener));
index.getRelationships(
element,
IndexConstants.DEFINES_CLASS_ALIAS,
newCallback(MatchKind.CLASS_ALIAS_DECLARATION, scope, listener));
index.getRelationships(
element,
IndexConstants.DEFINES_FUNCTION_TYPE,
newCallback(MatchKind.FUNCTION_TYPE_DECLARATION, scope, listener));
}
}
@Override
public List<SearchMatch> searchVariableDeclarations(final SearchScope scope,
final SearchPattern pattern, final SearchFilter filter) {
return gatherResults(new SearchRunner() {
@Override
public void performSearch(SearchListener listener) {
searchVariableDeclarations(scope, pattern, filter, listener);
}
});
}
@Override
public void searchVariableDeclarations(SearchScope scope, SearchPattern pattern,
SearchFilter filter, SearchListener listener) {
assert listener != null;
Element[] elements = createElements(scope);
listener = applyPattern(pattern, listener);
listener = applyFilter(filter, listener);
listener = new CountingSearchListener(elements.length, listener);
for (Element element : elements) {
index.getRelationships(
element,
IndexConstants.DEFINES_VARIABLE,
newCallback(MatchKind.VARIABLE_DECLARATION, scope, listener));
}
}
/**
* Use the given runner to perform the given number of asynchronous searches, then wait until the
* search has completed and return the results that were produced.
*
* @param runner the runner used to perform an asynchronous search
* @return the results that were produced @ if the results of at least one of the searched could
* not be computed
*/
private List<SearchMatch> gatherResults(SearchRunner runner) {
GatheringSearchListener listener = new GatheringSearchListener();
runner.performSearch(listener);
while (!listener.isComplete()) {
Thread.yield();
}
return listener.getMatches();
}
private void searchReferences(AngularElement element, SearchScope scope, SearchFilter filter,
SearchListener listener) {
assert listener != null;
listener = applyFilter(filter, listener);
listener = new CountingSearchListener(2, listener);
index.getRelationships(
element,
IndexConstants.ANGULAR_REFERENCE,
newCallback(MatchKind.ANGULAR_REFERENCE, scope, listener));
index.getRelationships(
element,
IndexConstants.ANGULAR_CLOSING_TAG_REFERENCE,
newCallback(MatchKind.ANGULAR_CLOSING_TAG_REFERENCE, scope, listener));
}
private void searchReferences(ClassElement type, SearchScope scope, SearchFilter filter,
SearchListener listener) {
assert listener != null;
listener = applyFilter(filter, listener);
index.getRelationships(
type,
IndexConstants.IS_REFERENCED_BY,
newCallback(MatchKind.TYPE_REFERENCE, scope, listener));
}
private void searchReferences(CompilationUnitElement unit, SearchScope scope,
SearchFilter filter, SearchListener listener) {
assert listener != null;
listener = applyFilter(filter, listener);
index.getRelationships(
unit,
IndexConstants.IS_REFERENCED_BY,
newCallback(MatchKind.UNIT_REFERENCE, scope, listener));
}
private void searchReferences(ConstructorElement constructor, SearchScope scope,
SearchFilter filter, SearchListener listener) {
assert listener != null;
listener = applyFilter(filter, listener);
listener = new CountingSearchListener(2, listener);
index.getRelationships(
constructor,
IndexConstants.IS_DEFINED_BY,
newCallback(MatchKind.CONSTRUCTOR_DECLARATION, scope, listener));
index.getRelationships(
constructor,
IndexConstants.IS_REFERENCED_BY,
newCallback(MatchKind.CONSTRUCTOR_REFERENCE, scope, listener));
}
private void searchReferences(FunctionElement function, SearchScope scope, SearchFilter filter,
SearchListener listener) {
assert listener != null;
listener = applyFilter(filter, listener);
listener = new CountingSearchListener(2, listener);
index.getRelationships(
function,
IndexConstants.IS_REFERENCED_BY,
newCallback(MatchKind.FUNCTION_REFERENCE, scope, listener));
index.getRelationships(
function,
IndexConstants.IS_INVOKED_BY,
newCallback(MatchKind.FUNCTION_EXECUTION, scope, listener));
}
private void searchReferences(FunctionTypeAliasElement alias, SearchScope scope,
SearchFilter filter, SearchListener listener) {
assert listener != null;
listener = applyFilter(filter, listener);
index.getRelationships(
alias,
IndexConstants.IS_REFERENCED_BY,
newCallback(MatchKind.FUNCTION_TYPE_REFERENCE, scope, listener));
}
private void searchReferences(ImportElement imp, SearchScope scope, SearchFilter filter,
SearchListener listener) {
assert listener != null;
listener = applyFilter(filter, listener);
index.getRelationships(
imp,
IndexConstants.IS_REFERENCED_BY,
newCallback(MatchKind.IMPORT_REFERENCE, scope, listener));
}
private void searchReferences(LibraryElement library, SearchScope scope, SearchFilter filter,
SearchListener listener) {
assert listener != null;
listener = applyFilter(filter, listener);
index.getRelationships(
library,
IndexConstants.IS_REFERENCED_BY,
newCallback(MatchKind.LIBRARY_REFERENCE, scope, listener));
}
private void searchReferences(MethodElement method, SearchScope scope, SearchFilter filter,
SearchListener listener) {
assert listener != null;
listener = applyFilter(filter, listener);
// TODO(scheglov) use "5" when add named matches
listener = new CountingSearchListener(4, listener);
// exact matches
index.getRelationships(
method,
IndexConstants.IS_INVOKED_BY_UNQUALIFIED,
newCallback(MatchKind.METHOD_INVOCATION, scope, listener));
index.getRelationships(
method,
IndexConstants.IS_INVOKED_BY_QUALIFIED,
newCallback(MatchKind.METHOD_INVOCATION, scope, listener));
index.getRelationships(
method,
IndexConstants.IS_REFERENCED_BY_UNQUALIFIED,
newCallback(MatchKind.METHOD_REFERENCE, scope, listener));
index.getRelationships(
method,
IndexConstants.IS_REFERENCED_BY_QUALIFIED,
newCallback(MatchKind.METHOD_REFERENCE, scope, listener));
// TODO(scheglov)
// inexact matches
// index.getRelationships(
// new Element(IndexConstants.DYNAMIC, method.getElementName()),
// IndexConstants.IS_INVOKED_BY_QUALIFIED,
// newCallback(MatchKind.METHOD_INVOCATION, listener));
}
private void searchReferences(ParameterElement parameter, SearchScope scope, SearchFilter filter,
SearchListener listener) {
assert listener != null;
listener = applyFilter(filter, listener);
listener = new CountingSearchListener(5, listener);
index.getRelationships(
parameter,
IndexConstants.IS_READ_BY,
newCallback(MatchKind.VARIABLE_READ, scope, listener));
index.getRelationships(
parameter,
IndexConstants.IS_READ_WRITTEN_BY,
newCallback(MatchKind.VARIABLE_READ_WRITE, scope, listener));
index.getRelationships(
parameter,
IndexConstants.IS_WRITTEN_BY,
newCallback(MatchKind.VARIABLE_WRITE, scope, listener));
index.getRelationships(
parameter,
IndexConstants.IS_REFERENCED_BY,
newCallback(MatchKind.NAMED_PARAMETER_REFERENCE, scope, listener));
index.getRelationships(
parameter,
IndexConstants.IS_INVOKED_BY,
newCallback(MatchKind.FUNCTION_EXECUTION, scope, listener));
}
private void searchReferences(PropertyAccessorElement accessor, SearchScope scope,
SearchFilter filter, SearchListener listener) {
assert listener != null;
listener = applyFilter(filter, listener);
listener = new CountingSearchListener(2, listener);
index.getRelationships(
accessor,
IndexConstants.IS_REFERENCED_BY_QUALIFIED,
newCallback(MatchKind.PROPERTY_ACCESSOR_REFERENCE, scope, listener));
index.getRelationships(
accessor,
IndexConstants.IS_REFERENCED_BY_UNQUALIFIED,
newCallback(MatchKind.PROPERTY_ACCESSOR_REFERENCE, scope, listener));
}
private void searchReferences(PropertyInducingElement field, SearchScope scope,
SearchFilter filter, SearchListener listener) {
assert listener != null;
PropertyAccessorElement getter = field.getGetter();
PropertyAccessorElement setter = field.getSetter();
int numRequests = (getter != null ? 4 : 0) + (setter != null ? 2 : 0) + 2;
listener = applyFilter(filter, listener);
listener = new CountingSearchListener(numRequests, listener);
if (getter != null) {
index.getRelationships(
getter,
IndexConstants.IS_REFERENCED_BY_QUALIFIED,
newCallback(MatchKind.FIELD_READ, scope, listener));
index.getRelationships(
getter,
IndexConstants.IS_REFERENCED_BY_UNQUALIFIED,
newCallback(MatchKind.FIELD_READ, scope, listener));
index.getRelationships(
getter,
IndexConstants.IS_INVOKED_BY_QUALIFIED,
newCallback(MatchKind.FIELD_INVOCATION, scope, listener));
index.getRelationships(
getter,
IndexConstants.IS_INVOKED_BY_UNQUALIFIED,
newCallback(MatchKind.FIELD_INVOCATION, scope, listener));
}
if (setter != null) {
index.getRelationships(
setter,
IndexConstants.IS_REFERENCED_BY_QUALIFIED,
newCallback(MatchKind.FIELD_WRITE, scope, listener));
index.getRelationships(
setter,
IndexConstants.IS_REFERENCED_BY_UNQUALIFIED,
newCallback(MatchKind.FIELD_WRITE, scope, listener));
}
index.getRelationships(
field,
IndexConstants.IS_REFERENCED_BY,
newCallback(MatchKind.FIELD_REFERENCE, scope, listener));
index.getRelationships(
field,
IndexConstants.IS_REFERENCED_BY_QUALIFIED,
newCallback(MatchKind.FIELD_REFERENCE, scope, listener));
}
private void searchReferences(TypeParameterElement typeParameter, SearchScope scope,
SearchFilter filter, SearchListener listener) {
assert listener != null;
listener = applyFilter(filter, listener);
index.getRelationships(
typeParameter,
IndexConstants.IS_REFERENCED_BY,
newCallback(MatchKind.TYPE_PARAMETER_REFERENCE, scope, listener));
}
private void searchReferences(VariableElement variable, SearchScope scope, SearchFilter filter,
SearchListener listener) {
assert listener != null;
listener = applyFilter(filter, listener);
listener = new CountingSearchListener(4, listener);
index.getRelationships(
variable,
IndexConstants.IS_READ_BY,
newCallback(MatchKind.VARIABLE_READ, scope, listener));
index.getRelationships(
variable,
IndexConstants.IS_READ_WRITTEN_BY,
newCallback(MatchKind.VARIABLE_READ_WRITE, scope, listener));
index.getRelationships(
variable,
IndexConstants.IS_WRITTEN_BY,
newCallback(MatchKind.VARIABLE_WRITE, scope, listener));
index.getRelationships(
variable,
IndexConstants.IS_INVOKED_BY,
newCallback(MatchKind.FUNCTION_EXECUTION, scope, listener));
}
}