/** * GWT client implementation of {@link WorkspaceService#symbol(WorkspaceSymbolParams)} * * @param params * @return */ public Promise<List<SymbolInformation>> symbol(WorkspaceSymbolParams params) { return Promises.create( (resolve, reject) -> requestTransmitter .newRequest() .endpointId(WS_AGENT_JSON_RPC_ENDPOINT_ID) .methodName("workspace/symbol") .paramsAsDto(params) .sendAndReceiveResultAsListOfDto(SymbolInformation.class) .onSuccess(resolve::apply) .onFailure(error -> reject.apply(getPromiseError(error)))); }
private void addAllSymbols(final ArrayList<SymbolInformation> results, final String query, final SomStructures probe, final String documentUri) { synchronized (probe) { Set<MixinDefinition> classes = probe.getClasses(); for (MixinDefinition m : classes) { assert sameDocument(documentUri, m.getSourceSection()); addSymbolInfo(m, query, results); } Set<SInvokable> methods = probe.getMethods(); for (SInvokable m : methods) { assert sameDocument(documentUri, m.getSourceSection()); if (matchQuery(query, m)) { results.add(getSymbolInfo(m)); } } } }
private static void addSymbolInfo(final MixinDefinition m, final String query, final ArrayList<SymbolInformation> results) { if (matchQuery(query, m)) { results.add(getSymbolInfo(m)); } // We add the slots here, because we have more context at this point for (Dispatchable d : m.getInstanceDispatchables().values()) { // needs to be exact test to avoid duplicate info if (d.getClass() == SlotDefinition.class) { if (matchQuery(query, (SlotDefinition) d)) { results.add(getSymbolInfo((SlotDefinition) d, m)); } } } }
@Test public void testWorkspaceSearch() { String query = "Abstract"; List<SymbolInformation> results = handler.search(query, monitor); assertNotNull(results); assertEquals("Found " + results.size() + " results", 33, results.size()); Range defaultRange = JDTUtils.newRange(); for (SymbolInformation symbol : results) { assertNotNull("Kind is missing", symbol.getKind()); assertNotNull("ContainerName is missing", symbol.getContainerName()); assertTrue(symbol.getName().startsWith(query)); Location location = symbol.getLocation(); assertEquals(defaultRange, location.getRange()); //No class in the workspace project starts with Abstract, so everything comes from the JDK assertTrue("Unexpected uri "+ location.getUri(), location.getUri().startsWith("jdt://")); } }
@Test public void testSyntheticMember() throws Exception { String className = "org.apache.commons.lang3.text.StrTokenizer"; List<? extends SymbolInformation> symbols = getSymbols(className); boolean overloadedMethod1Found = false; boolean overloadedMethod2Found = false; String overloadedMethod1 = "getCSVInstance(String)"; String overloadedMethod2 = "reset()"; for (SymbolInformation symbol : symbols) { Location loc = symbol.getLocation(); assertTrue("Class: " + className + ", Symbol:" + symbol.getName() + " - invalid location.", loc != null && isValid(loc.getRange())); assertFalse("Class: " + className + ", Symbol:" + symbol.getName() + " - invalid name", symbol.getName().startsWith("access$")); assertFalse("Class: " + className + ", Symbol:" + symbol.getName() + "- invalid name", symbol.getName().equals("<clinit>")); if (overloadedMethod1.equals(symbol.getName())) { overloadedMethod1Found = true; } if (overloadedMethod2.equals(symbol.getName())) { overloadedMethod2Found = true; } } assertTrue("The " + overloadedMethod1 + " method hasn't been found", overloadedMethod1Found); assertTrue("The " + overloadedMethod2 + " method hasn't been found", overloadedMethod2Found); }
protected void testDocumentSymbol(final Procedure1<? super DocumentSymbolConfiguraiton> configurator) { try { @Extension final DocumentSymbolConfiguraiton configuration = new DocumentSymbolConfiguraiton(); configuration.setFilePath(("MyModel." + this.fileExtension)); configurator.apply(configuration); final String fileUri = this.initializeContext(configuration).getUri(); TextDocumentIdentifier _textDocumentIdentifier = new TextDocumentIdentifier(fileUri); DocumentSymbolParams _documentSymbolParams = new DocumentSymbolParams(_textDocumentIdentifier); final CompletableFuture<List<? extends SymbolInformation>> symbolsFuture = this.languageServer.documentSymbol(_documentSymbolParams); final List<? extends SymbolInformation> symbols = symbolsFuture.get(); Procedure1<? super List<? extends SymbolInformation>> _assertSymbols = configuration.getAssertSymbols(); boolean _tripleNotEquals = (_assertSymbols != null); if (_tripleNotEquals) { configuration.getAssertSymbols().apply(symbols); } else { final String actualSymbols = this.toExpectation(symbols); this.assertEquals(configuration.getExpectedSymbols(), actualSymbols); } } catch (Throwable _e) { throw Exceptions.sneakyThrow(_e); } }
protected void testSymbol(final Procedure1<? super WorkspaceSymbolConfiguraiton> configurator) { try { @Extension final WorkspaceSymbolConfiguraiton configuration = new WorkspaceSymbolConfiguraiton(); configuration.setFilePath(("MyModel." + this.fileExtension)); configurator.apply(configuration); this.initializeContext(configuration); String _query = configuration.getQuery(); WorkspaceSymbolParams _workspaceSymbolParams = new WorkspaceSymbolParams(_query); final List<? extends SymbolInformation> symbols = this.languageServer.symbol(_workspaceSymbolParams).get(); Procedure1<? super List<? extends SymbolInformation>> _assertSymbols = configuration.getAssertSymbols(); boolean _tripleNotEquals = (_assertSymbols != null); if (_tripleNotEquals) { configuration.getAssertSymbols().apply(symbols); } else { final String actualSymbols = this.toExpectation(symbols); this.assertEquals(configuration.getExpectedSymbols(), actualSymbols); } } catch (Throwable _e) { throw Exceptions.sneakyThrow(_e); } }
@Override public CompletableFuture<List<? extends SymbolInformation>> documentSymbol(final DocumentSymbolParams params) { final Function1<CancelIndicator, List<? extends SymbolInformation>> _function = (CancelIndicator cancelIndicator) -> { final URI uri = this._uriExtensions.toUri(params.getTextDocument().getUri()); final IResourceServiceProvider resourceServiceProvider = this.languagesRegistry.getResourceServiceProvider(uri); DocumentSymbolService _get = null; if (resourceServiceProvider!=null) { _get=resourceServiceProvider.<DocumentSymbolService>get(DocumentSymbolService.class); } final DocumentSymbolService documentSymbolService = _get; if ((documentSymbolService == null)) { return CollectionLiterals.<SymbolInformation>emptyList(); } final Function2<Document, XtextResource, List<? extends SymbolInformation>> _function_1 = (Document document, XtextResource resource) -> { return documentSymbolService.getSymbols(document, resource, params, cancelIndicator); }; return this.workspaceManager.<List<? extends SymbolInformation>>doRead(uri, _function_1); }; return this.requestManager.<List<? extends SymbolInformation>>runRead(_function); }
public List<? extends SymbolInformation> getSymbols(final String query, final IReferenceFinder.IResourceAccess resourceAccess, final IResourceDescriptions indexData, final CancelIndicator cancelIndicator) { final LinkedList<SymbolInformation> result = CollectionLiterals.<SymbolInformation>newLinkedList(); Iterable<IResourceDescription> _allResourceDescriptions = indexData.getAllResourceDescriptions(); for (final IResourceDescription resourceDescription : _allResourceDescriptions) { { this.operationCanceledManager.checkCanceled(cancelIndicator); final IResourceServiceProvider resourceServiceProvider = this._registry.getResourceServiceProvider(resourceDescription.getURI()); DocumentSymbolService _get = null; if (resourceServiceProvider!=null) { _get=resourceServiceProvider.<DocumentSymbolService>get(DocumentSymbolService.class); } final DocumentSymbolService documentSymbolService = _get; if ((documentSymbolService != null)) { List<? extends SymbolInformation> _symbols = documentSymbolService.getSymbols(resourceDescription, query, resourceAccess, cancelIndicator); Iterables.<SymbolInformation>addAll(result, _symbols); } } } return result; }
public List<? extends SymbolInformation> getSymbols(final XtextResource resource, final CancelIndicator cancelIndicator) { final LinkedHashMap<EObject, SymbolInformation> symbols = CollectionLiterals.<EObject, SymbolInformation>newLinkedHashMap(); final TreeIterator<Object> contents = EcoreUtil.<Object>getAllProperContents(resource, true); while (contents.hasNext()) { { this.operationCanceledManager.checkCanceled(cancelIndicator); Object _next = contents.next(); final EObject obj = ((EObject) _next); final SymbolInformation symbol = this.createSymbol(obj); if ((symbol != null)) { symbols.put(obj, symbol); final EObject container = this.getContainer(obj); final SymbolInformation containerSymbol = symbols.get(container); String _name = null; if (containerSymbol!=null) { _name=containerSymbol.getName(); } symbol.setContainerName(_name); } } } return IterableExtensions.<SymbolInformation>toList(symbols.values()); }
protected SymbolInformation createSymbol(final EObject object) { final String name = this.getSymbolName(object); if ((name == null)) { return null; } final SymbolKind kind = this.getSymbolKind(object); if ((kind == null)) { return null; } final Location location = this.getSymbolLocation(object); if ((location == null)) { return null; } final SymbolInformation symbol = new SymbolInformation(); symbol.setName(name); symbol.setKind(kind); symbol.setLocation(location); return symbol; }
public List<? extends SymbolInformation> getSymbols(final IResourceDescription resourceDescription, final String query, final IReferenceFinder.IResourceAccess resourceAccess, final CancelIndicator cancelIndicator) { final LinkedList<SymbolInformation> symbols = CollectionLiterals.<SymbolInformation>newLinkedList(); Iterable<IEObjectDescription> _exportedObjects = resourceDescription.getExportedObjects(); for (final IEObjectDescription description : _exportedObjects) { { this.operationCanceledManager.checkCanceled(cancelIndicator); boolean _filter = this.filter(description, query); if (_filter) { final Procedure1<SymbolInformation> _function = (SymbolInformation symbol) -> { symbols.add(symbol); }; this.createSymbol(description, resourceAccess, _function); } } } return symbols; }
private Promise<List<SymbolEntry>> searchSymbols(final String value) { ExtendedWorkspaceSymbolParams params = dtoFactory.createDto(ExtendedWorkspaceSymbolParams.class); params.setQuery(value); params.setFileUri( editorAgent.getActiveEditor().getEditorInput().getFile().getLocation().toString()); return workspaceServiceClient .symbol(params) .then( new Function<List<SymbolInformation>, List<SymbolEntry>>() { @Override public List<SymbolEntry> apply(List<SymbolInformation> types) throws FunctionException { return toSymbolEntries(types, value); } }); }
@Override public CompletableFuture<List<? extends SymbolInformation>> symbol(WorkspaceSymbolParams params) { return null; }
@Override public CompletableFuture<List<? extends SymbolInformation>> documentSymbol( final DocumentSymbolParams params) { List<? extends SymbolInformation> result = som.getSymbolInfo(params.getTextDocument().getUri()); return CompletableFuture.completedFuture(result); }
public List<? extends SymbolInformation> getSymbolInfo(final String documentUri) { SomStructures probe = getProbe(documentUri); ArrayList<SymbolInformation> results = new ArrayList<>(); if (probe == null) { return results; } addAllSymbols(results, null, probe, documentUri); return results; }
public List<? extends SymbolInformation> getAllSymbolInfo(final String query) { Collection<SomStructures> probes = getProbes(); ArrayList<SymbolInformation> results = new ArrayList<>(); for (SomStructures probe : probes) { addAllSymbols(results, query, probe, probe.getDocumentUri()); } return results; }
private static SymbolInformation getSymbolInfo(final SInvokable m) { SymbolInformation sym = new SymbolInformation(); sym.setName(m.getSignature().toString()); sym.setKind(SymbolKind.Method); if (null != m.getSourceSection()) { sym.setLocation(getLocation(m.getSourceSection())); } if (m.getHolderUnsafe() != null) { sym.setContainerName(m.getHolder().getName().getString()); } return sym; }
private static SymbolInformation getSymbolInfo(final SlotDefinition d, final MixinDefinition m) { SymbolInformation sym = new SymbolInformation(); sym.setName(d.getName().getString()); SymbolKind kind = m.isModule() ? SymbolKind.Constant : SymbolKind.Property; sym.setKind(kind); sym.setLocation(getLocation(d.getSourceSection())); sym.setContainerName(m.getName().getString()); return sym; }
private static SymbolInformation getSymbolInfo(final MixinDefinition m) { SymbolInformation sym = new SymbolInformation(); sym.setName(m.getName().getString()); SymbolKind kind = m.isModule() ? SymbolKind.Module : SymbolKind.Class; sym.setKind(kind); sym.setLocation(getLocation(m.getSourceSection())); MixinDefinition outer = m.getOuterMixinDefinition(); if (outer != null) { sym.setContainerName(outer.getName().getString()); } return sym; }
public List<? extends SymbolInformation> documentSymbol(DocumentSymbolParams params, IProgressMonitor monitor) { ITypeRoot unit = JDTUtils.resolveTypeRoot(params.getTextDocument().getUri()); if (unit == null) { return Collections.emptyList(); } SymbolInformation[] elements = this.getOutline(unit, monitor); return Arrays.asList(elements); }
private SymbolInformation[] getOutline(ITypeRoot unit, IProgressMonitor monitor) { try { IJavaElement[] elements = unit.getChildren(); ArrayList<SymbolInformation> symbols = new ArrayList<>(elements.length); collectChildren(unit, elements, symbols, monitor); return symbols.toArray(new SymbolInformation[symbols.size()]); } catch (JavaModelException e) { JavaLanguageServerPlugin.logException("Problem getting outline for" + unit.getElementName(), e); } return new SymbolInformation[0]; }
private void collectChildren(ITypeRoot unit, IJavaElement[] elements, ArrayList<SymbolInformation> symbols, IProgressMonitor monitor) throws JavaModelException { for(IJavaElement element : elements ){ if (monitor.isCanceled()) { return; } if(element instanceof IParent){ collectChildren(unit, filter(((IParent) element).getChildren()), symbols, monitor); } int type = element.getElementType(); if (type != IJavaElement.TYPE && type != IJavaElement.FIELD && type != IJavaElement.METHOD) { continue; } Location location = JDTUtils.toLocation(element); if (location != null) { SymbolInformation si = new SymbolInformation(); String name = JavaElementLabels.getElementLabel(element, JavaElementLabels.ALL_DEFAULT); si.setName(name == null ? element.getElementName() : name); si.setKind(mapKind(element)); if (element.getParent() != null) { si.setContainerName(element.getParent().getElementName()); } location.setUri(ResourceUtils.toClientUri(location.getUri())); si.setLocation(location); if (!symbols.contains(si)) { symbols.add(si); } } } }
@Override public CompletableFuture<List<? extends SymbolInformation>> symbol(WorkspaceSymbolParams params) { logInfo(">> workspace/symbol"); WorkspaceSymbolHandler handler = new WorkspaceSymbolHandler(); return computeAsync((cc) -> { return handler.search(params.getQuery(), toMonitor(cc)); }); }
@Test public void testSearchWithEmptyResults() { List<SymbolInformation> results = handler.search(null, monitor); assertNotNull(results); assertEquals(0, results.size()); results = handler.search(" ", monitor); assertNotNull(results); assertEquals(0, results.size()); results = handler.search("Abracadabra", monitor); assertNotNull(results); assertEquals(0, results.size()); }
@Test public void testProjectSearch() { String query = "IFoo"; List<SymbolInformation> results = handler.search(query, monitor); assertNotNull(results); assertEquals("Found "+ results.size() + " results", 1, results.size()); SymbolInformation symbol = results.get(0); assertEquals(SymbolKind.Interface, symbol.getKind()); assertEquals("java", symbol.getContainerName()); assertEquals(query, symbol.getName()); Location location = symbol.getLocation(); assertEquals(JDTUtils.newRange(), location.getRange()); assertTrue("Unexpected uri "+ location.getUri(), location.getUri().endsWith("Foo.java")); }
@Test public void testCamelCaseSearch() { List<SymbolInformation> results = handler.search("NPE", monitor); assertNotNull(results); assertEquals("NullPointerException", results.get(0).getName()); results = handler.search("HaMa", monitor); String className = "HashMap"; boolean foundClass = results.stream().filter(s -> className.equals(s.getName())).findFirst().isPresent(); assertTrue("Did not find "+className, foundClass); }
@Test public void testTypes() throws Exception { String className = "org.sample.Bar"; List<? extends SymbolInformation> symbols = getSymbols(className); assertHasSymbol("Bar", "Bar.java", SymbolKind.Class, symbols); assertHasSymbol("main(String[])", "Bar", SymbolKind.Method, symbols); assertHasSymbol("MyInterface", "Bar", SymbolKind.Interface, symbols); assertHasSymbol("foo()", "MyInterface", SymbolKind.Method, symbols); assertHasSymbol("MyClass", "Bar", SymbolKind.Class, symbols); assertHasSymbol("bar()", "MyClass", SymbolKind.Method, symbols); }
private void assertHasSymbol(String expectedType, String expectedParent, SymbolKind expectedKind, Collection<? extends SymbolInformation> symbols) { Optional<? extends SymbolInformation> symbol = symbols.stream() .filter(s -> expectedType.equals(s.getName()) && expectedParent.equals(s.getContainerName())) .findFirst(); assertTrue(expectedType + "(" + expectedParent + ")" + " is missing from " + symbols, symbol.isPresent()); assertKind(expectedKind, symbol.get()); }
private void testClass(String className) throws JavaModelException, UnsupportedEncodingException, InterruptedException, ExecutionException { List<? extends SymbolInformation> symbols = getSymbols(className); for (SymbolInformation symbol : symbols) { Location loc = symbol.getLocation(); assertTrue("Class: " + className + ", Symbol:" + symbol.getName() + " - invalid location.", loc != null && isValid(loc.getRange())); } }
private List<? extends SymbolInformation> getSymbols(String className) throws JavaModelException, UnsupportedEncodingException, InterruptedException, ExecutionException { String uri = ClassFileUtil.getURI(project, className); TextDocumentIdentifier identifier = new TextDocumentIdentifier(uri); DocumentSymbolParams params = new DocumentSymbolParams(); params.setTextDocument(identifier); List<? extends SymbolInformation> symbols = handler.documentSymbol(params, monitor); assertTrue(symbols.size() > 0); return symbols; }
protected String _toExpectation(final SymbolInformation it) { StringConcatenation _builder = new StringConcatenation(); _builder.append("symbol \""); String _name = it.getName(); _builder.append(_name); _builder.append("\" {"); _builder.newLineIfNotEmpty(); _builder.append(" "); _builder.append("kind: "); int _value = it.getKind().getValue(); _builder.append(_value, " "); _builder.newLineIfNotEmpty(); _builder.append(" "); _builder.append("location: "); String _expectation = this.toExpectation(it.getLocation()); _builder.append(_expectation, " "); _builder.newLineIfNotEmpty(); { boolean _isNullOrEmpty = StringExtensions.isNullOrEmpty(it.getContainerName()); boolean _not = (!_isNullOrEmpty); if (_not) { _builder.append(" "); _builder.append("container: \""); String _containerName = it.getContainerName(); _builder.append(_containerName, " "); _builder.append("\""); _builder.newLineIfNotEmpty(); } } _builder.append("}"); _builder.newLine(); return _builder.toString(); }
@Override public CompletableFuture<List<? extends SymbolInformation>> symbol(final WorkspaceSymbolParams params) { final Function1<CancelIndicator, List<? extends SymbolInformation>> _function = (CancelIndicator cancelIndicator) -> { final IResourceDescriptions indexData = this.workspaceManager.getIndex(); return this.workspaceSymbolService.getSymbols(params.getQuery(), this.resourceAccess, indexData, cancelIndicator); }; return this.requestManager.<List<? extends SymbolInformation>>runRead(_function); }
protected void createSymbol(final IEObjectDescription description, final IReferenceFinder.IResourceAccess resourceAccess, final Procedure1<? super SymbolInformation> acceptor) { final String name = this.getSymbolName(description); if ((name == null)) { return; } final SymbolKind kind = this.getSymbolKind(description); if ((kind == null)) { return; } final Procedure1<Location> _function = (Location location) -> { final SymbolInformation symbol = new SymbolInformation(name, kind, location); acceptor.apply(symbol); }; this.getSymbolLocation(description, resourceAccess, _function); }
protected SymbolInformation createSymbol(final IEObjectDescription description) { final String symbolName = this.getSymbolName(description); if ((symbolName == null)) { return null; } final SymbolKind symbolKind = this.getSymbolKind(description); if ((symbolKind == null)) { return null; } final SymbolInformation symbol = new SymbolInformation(); symbol.setName(symbolName); symbol.setKind(symbolKind); return symbol; }
private List<SymbolEntry> toSymbolEntries(List<SymbolInformation> types, String value) { List<SymbolEntry> result = new ArrayList<>(); for (SymbolInformation element : types) { if (!SUPPORTED_OPEN_TYPES.contains(symbolKindHelper.from(element.getKind()))) { continue; } List<Match> matches = fuzzyMatches.fuzzyMatch(value, element.getName()); if (matches != null) { Location location = element.getLocation(); if (location != null && location.getUri() != null) { String filePath = location.getUri(); Range locationRange = location.getRange(); TextRange range = null; if (locationRange != null) { range = new TextRange( new TextPosition( locationRange.getStart().getLine(), locationRange.getStart().getCharacter()), new TextPosition( locationRange.getEnd().getLine(), locationRange.getEnd().getCharacter())); } result.add( new SymbolEntry( element.getName(), "", filePath, filePath, symbolKindHelper.from(element.getKind()), range, symbolKindHelper.getIcon(element.getKind()), editorHelper, matches)); } } } // TODO add sorting return result; }
@Override public CompletableFuture<List<? extends SymbolInformation>> documentSymbol(DocumentSymbolParams params) { LOGGER.info("documentSymbol: " + params.getTextDocument()); return CompletableFuture.completedFuture(Collections.emptyList()); }
@Override public CompletableFuture<List<? extends SymbolInformation>> symbol(WorkspaceSymbolParams params) { LOGGER.info("SERVER: symbolQuery: " + params.getQuery()); return CompletableFuture.completedFuture(Collections.emptyList()); }
@Override public CompletableFuture<List<? extends SymbolInformation>> symbol( final WorkspaceSymbolParams params) { List<? extends SymbolInformation> result = som.getAllSymbolInfo(params.getQuery()); return CompletableFuture.completedFuture(result); }
@Override public CompletableFuture<List<? extends SymbolInformation>> documentSymbol(DocumentSymbolParams params) { logInfo(">> document/documentSymbol"); DocumentSymbolHandler handler = new DocumentSymbolHandler(); return computeAsync((cc) -> handler.documentSymbol(params, toMonitor(cc))); }