org.eclipse.lsp4j.ReferenceParams Java Examples

@Test
public void testReference(){
	URI uri = project.getFile("src/java/Foo2.java").getRawLocationURI();
	String fileURI = ResourceUtils.fixURI(uri);

	ReferenceParams param = new ReferenceParams();
	param.setPosition(new Position(5,16));
	param.setContext(new ReferenceContext(true));
	param.setTextDocument( new TextDocumentIdentifier(fileURI));
	List<Location> references =  handler.findReferences(param, monitor);
	assertNotNull("findReferences should not return null",references);
	assertEquals(1, references.size());
	Location l = references.get(0);
	String refereeUri = ResourceUtils.fixURI(project.getFile("src/java/Foo3.java").getRawLocationURI());
	assertEquals(refereeUri, l.getUri());
}
 

@Override
public CompletableFuture<List<? extends Location>> references(ReferenceParams params) {
	return computeDOMAsync(params.getTextDocument(), (cancelChecker, xmlDocument) -> {
		return getXMLLanguageService().findReferences(xmlDocument, params.getPosition(), params.getContext(),
				cancelChecker);
	});
}
 

public List<? extends Location> getReferences(Document document, XtextResource resource, ReferenceParams params,
		IReferenceFinder.IResourceAccess resourceAccess, IResourceDescriptions indexData,
		CancelIndicator cancelIndicator) {
	int offset = document.getOffSet(params.getPosition());
	List<? extends Location> definitions = Collections.emptyList();
	if (params.getContext().isIncludeDeclaration()) {
		definitions = getDefinitions(resource, offset, resourceAccess, cancelIndicator);
	}
	List<? extends Location> references = getReferences(resource, offset, resourceAccess, indexData,
			cancelIndicator);
	List<Location> result = new ArrayList<>();
	result.addAll(definitions);
	result.addAll(references);
	return result;
}
 

protected CompletableFuture<List<? extends Location>> getReferencesFor(CamelLanguageServer camelLanguageServer, Position position, String uri) {
	TextDocumentService textDocumentService = camelLanguageServer.getTextDocumentService();
	ReferenceParams params = new ReferenceParams();
	params.setPosition(position);
	params.setTextDocument(new TextDocumentIdentifier(uri));
	return textDocumentService.references(params);
}
 

@Override
public CompletableFuture<List<? extends Location>> references(ReferenceParams params) {
	URI uri = getURI(params);
	return openFilesManager.runInOpenFileContext(uri, "references", (ofc, ci) -> {
		return references(ofc, params, ci);
	});
}
 

/**
 * Compute the references. Executed in read request.
 */
protected List<? extends Location> references(OpenFileContext ofc, ReferenceParams params,
		CancelIndicator cancelIndicator) {
	URI uri = ofc.getURI();
	DocumentSymbolService documentSymbolService = getService(uri, DocumentSymbolService.class);
	if ((documentSymbolService == null)) {
		return Collections.emptyList();
	}
	XtextResource res = ofc.getResource();
	XDocument doc = ofc.getDocument();
	return documentSymbolService.getReferences(doc, res, params, resourceAccess,
			openFilesManager.createLiveScopeIndex(), cancelIndicator);
}
 

/**
 * Compute the references. Executed in read request.
 * @since 2.20
 */
protected List<? extends Location> references(ReferenceParams params, CancelIndicator cancelIndicator) {
	URI uri = getURI(params);
	DocumentSymbolService documentSymbolService = getService(uri, DocumentSymbolService.class);
	if (documentSymbolService == null) {
		return Collections.emptyList();
	}
	return workspaceManager.doRead(uri, (document, resource) -> documentSymbolService.getReferences(document,
			resource, params, resourceAccess, workspaceManager.getIndex(), cancelIndicator));
}
 

@Override public IStatus run(IProgressMonitor monitor) {
	startTime = System.currentTimeMillis();
	// Cancel last references future if needed.
	if (references != null) {
		references.cancel(true);
	}
	AbstractTextSearchResult textResult = (AbstractTextSearchResult) getSearchResult();
	textResult.removeAll();

	try {
		// Execute LSP "references" service
		ReferenceParams params = new ReferenceParams();
		params.setContext(new ReferenceContext(true));
		params.setTextDocument(new TextDocumentIdentifier(info.getFileUri().toString()));
		params.setPosition(position);
		info.getInitializedLanguageClient().thenCompose(languageServer -> ((RLSServerInterface) languageServer).implementations(params)).thenAccept(locs -> {
			// Loop for each LSP Location and convert it to Match search.
			for (Location loc : locs) {
				Match match = toMatch(loc);
				result.addMatch(match);
			}
		});
		return Status.OK_STATUS;
	} catch (Exception ex) {
		return new Status(IStatus.ERROR, LanguageServerPlugin.getDefault().getBundle().getSymbolicName(), ex.getMessage(), ex);
	}
}
 

@Override
public CompletableFuture<List<? extends Location>> references(ReferenceParams params) {
	URI uri = URI.create(params.getTextDocument().getUri());
	recompileIfContextChanged(uri);

	ReferenceProvider provider = new ReferenceProvider(astVisitor);
	return provider.provideReferences(params.getTextDocument(), params.getPosition());
}
 

/**
 * Finds all references of the definition referenced at the current position
 * in a text document. Does not necessarily get called where a definition is
 * defined, but may be at one of the references.
 */
@Override
public CompletableFuture<List<? extends Location>> references(ReferenceParams params)
{
    return CompletableFutures.computeAsync(compilerWorkspace.getExecutorService(), cancelToken ->
    {
        cancelToken.checkCanceled();

        //make sure that the latest changes have been passed to
        //workspace.fileChanged() before proceeding
        if(realTimeProblemsChecker != null)
        {
            realTimeProblemsChecker.updateNow();
        }

        compilerWorkspace.startBuilding();
        try
        {
            ReferencesProvider provider = new ReferencesProvider(workspaceFolderManager, fileTracker);
            return provider.references(params, cancelToken);
        }
        finally
        {
            compilerWorkspace.doneBuilding();
        }
    });
}
 

@Test
public void testEmpty(){
	ReferenceParams param = new ReferenceParams();
	param.setPosition(new Position(1, 1));
	param.setContext(new ReferenceContext(false));
	param.setTextDocument( new TextDocumentIdentifier("/foo/bar"));
	List<Location> references =  handler.findReferences(param, monitor);
	assertNotNull(references);
	assertTrue("references are not empty", references.isEmpty());
}
 

@Override
public CompletableFuture<List<? extends Location>> references(ReferenceParams params) {
	logInfo(">> document/references");
	ReferencesHandler handler = new ReferencesHandler(this.preferenceManager);
	return computeAsync((monitor) -> handler.findReferences(params, monitor));
}
 

@Override
public CompletableFuture<List<? extends Location>> references(ReferenceParams params) {
	return requestManager.runRead(cancelIndicator -> references(params, cancelIndicator));
}
 

public List<Location> findReferences(ReferenceParams param, IProgressMonitor monitor) {

		final List<Location> locations = new ArrayList<>();
		try {
			IJavaElement elementToSearch = JDTUtils.findElementAtSelection(JDTUtils.resolveTypeRoot(param.getTextDocument().getUri()), param.getPosition().getLine(), param.getPosition().getCharacter(), this.preferenceManager, monitor);

			if (elementToSearch == null) {
				return locations;
			}

			boolean includeClassFiles = preferenceManager.isClientSupportsClassFileContent();
			SearchEngine engine = new SearchEngine();
			SearchPattern pattern = SearchPattern.createPattern(elementToSearch, IJavaSearchConstants.REFERENCES);

			engine.search(pattern, new SearchParticipant[] { SearchEngine.getDefaultSearchParticipant() }, createSearchScope(), new SearchRequestor() {

				@Override
				public void acceptSearchMatch(SearchMatch match) throws CoreException {
					Object o = match.getElement();
					if (o instanceof IJavaElement) {
						IJavaElement element = (IJavaElement) o;
						ICompilationUnit compilationUnit = (ICompilationUnit) element.getAncestor(IJavaElement.COMPILATION_UNIT);
						Location location = null;
						if (compilationUnit != null) {
							location = JDTUtils.toLocation(compilationUnit, match.getOffset(), match.getLength());
						} else if (includeClassFiles) {
							IClassFile cf = (IClassFile) element.getAncestor(IJavaElement.CLASS_FILE);
							if (cf != null && cf.getSourceRange() != null) {
								location = JDTUtils.toLocation(cf, match.getOffset(), match.getLength());
							}
						}
						if (location != null) {
							locations.add(location);
						}
					}
				}
			}, monitor);

		} catch (CoreException e) {
			JavaLanguageServerPlugin.logException("Find references failure ", e);
		}
		return locations;
	}
 

@Override
public CompletableFuture<List<? extends Location>> references(ReferenceParams params) {
    return CompletableFuture.completedFuture(Collections.emptyList());
}
 

@Override
public CompletableFuture<List<? extends Location>> references(ReferenceParams arg0) {
    throw new UnsupportedOperationException("Not supported yet.");
}
 

@Override
public CompletableFuture<List<? extends Location>> references(ReferenceParams params) {
	LOGGER.info("references: {}", params.getTextDocument());
	return new ReferencesProcessor(this, openedDocuments.get(params.getTextDocument().getUri())).getReferences(params.getPosition());
}
 

/**
 * The references request is sent from the client to the server to resolve
 * project-wide references for the symbol denoted by the given text document
 * position.
 * 
 * Registration Options: TextDocumentRegistrationOptions
 */
@JsonRequest
default CompletableFuture<List<? extends Location>> references(ReferenceParams params) {
	throw new UnsupportedOperationException();
}