@Test public void testChangeEventUpdatesStoredText() throws Exception { CamelLanguageServer camelLanguageServer = initializeLanguageServer("<to uri=\"\" xmlns=\"http://camel.apache.org/schema/blueprint\"></to>\n"); DidChangeTextDocumentParams changeEvent = new DidChangeTextDocumentParams(); VersionedTextDocumentIdentifier textDocument = new VersionedTextDocumentIdentifier(); textDocument.setUri(DUMMY_URI); changeEvent.setTextDocument(textDocument); TextDocumentContentChangeEvent contentChange = new TextDocumentContentChangeEvent("<to xmlns=\"http://camel.apache.org/schema/blueprint\" uri=\"\"></to>\n"); changeEvent.setContentChanges(Collections.singletonList(contentChange)); camelLanguageServer.getTextDocumentService().didChange(changeEvent); //check old position doesn't provide completion CompletableFuture<Either<List<CompletionItem>, CompletionList>> completionsAtOldPosition = getCompletionFor(camelLanguageServer, new Position(0, 11)); assertThat(completionsAtOldPosition.get().getLeft()).isEmpty(); //check new position provides completion CompletableFuture<Either<List<CompletionItem>, CompletionList>> completionsAtNewPosition = getCompletionFor(camelLanguageServer, new Position(0, 58)); assertThat(completionsAtNewPosition.get().getLeft()).isNotEmpty(); }
public DSPDebugTarget(ILaunch launch, Process process, InputStream in, OutputStream out, Map<String, Object> launchArguments) throws CoreException { super(null); this.launch = launch; this.process = process; DebugLauncher<IDebugProtocolServer> debugProtocolLauncher = DebugLauncher.createLauncher(this, IDebugProtocolServer.class, in, out, true, new PrintWriter(System.out)); debugProtocolFuture = debugProtocolLauncher.startListening(); debugProtocolServer = debugProtocolLauncher.getRemoteProxy(); complete(debugProtocolServer.initialize(new InitializeRequestArguments().setClientID("lsp4e") .setAdapterID((String) launchArguments.get("type")).setPathFormat("path"))); Object object = launchArguments.get("program"); targetName = Objects.toString(object, "Debug Adapter Target"); complete(debugProtocolServer.launch(Either.forLeft(launchArguments))); complete(debugProtocolServer.configurationDone()); IBreakpointManager breakpointManager = getBreakpointManager(); breakpointManager.addBreakpointListener(this); breakpointManager.addBreakpointManagerListener(this); breakpointManagerEnablementChanged(breakpointManager.isEnabled()); }
@SuppressWarnings({ "unchecked" }) @Test public void testEither_02() { Map<String, JsonRpcMethod> supportedMethods = new LinkedHashMap<>(); supportedMethods.put("foo", JsonRpcMethod.request("foo", new TypeToken<Either<MyEnum, Map<String,String>>>() {}.getType(), new TypeToken<Object>() {}.getType())); DebugMessageJsonHandler handler = new DebugMessageJsonHandler(supportedMethods); handler.setMethodProvider((id) -> "foo"); Message message = handler.parseMessage("{" + "\"seq\":2,\n" + "\"type\":\"response\",\n" + "\"body\": 2\n" + "}"); Either<MyEnum, List<Map<String, String>>> result = (Either<MyEnum, List<Map<String,String>>>) ((ResponseMessage)message).getResult(); Assert.assertTrue(result.isLeft()); Assert.assertEquals(MyEnum.B, result.getLeft()); }
@SuppressWarnings("unchecked") protected Either<L, R> create(JsonToken nextToken, JsonReader in) throws IOException { if (left.isAssignable(nextToken)) { if (Either3.class.isAssignableFrom(typeToken.getRawType())) return (Either<L, R>) Either3.forLeft3(left.read(in)); else return Either.forLeft(left.read(in)); } if (right.isAssignable(nextToken)) { if (Either3.class.isAssignableFrom(typeToken.getRawType())) return (Either<L, R>) Either3.forRight3((Either<?, ?>) right.read(in)); else return Either.forRight(right.read(in)); } return null; }
Either<List<CompletionItem>, CompletionList> completion(TextDocumentPositionParams position, IProgressMonitor monitor) { List<CompletionItem> completionItems = null; try { ICompilationUnit unit = JDTUtils.resolveCompilationUnit(position.getTextDocument().getUri()); completionItems = this.computeContentAssist(unit, position.getPosition().getLine(), position.getPosition().getCharacter(), monitor); } catch (OperationCanceledException ignorable) { // No need to pollute logs when query is cancelled monitor.setCanceled(true); } catch (Exception e) { JavaLanguageServerPlugin.logException("Problem with codeComplete for " + position.getTextDocument().getUri(), e); monitor.setCanceled(true); } CompletionList $ = new CompletionList(); if (monitor.isCanceled()) { $.setIsIncomplete(true); completionItems = null; JavaLanguageServerPlugin.logInfo("Completion request cancelled"); } else { JavaLanguageServerPlugin.logInfo("Completion request completed"); } $.setItems(completionItems == null ? Collections.emptyList() : completionItems); return Either.forRight($); }
@Override public CompletableFuture<Either<List<CompletionItem>, CompletionList>> completion(TextDocumentPositionParams position) { logInfo(">> document/completion"); CompletionHandler handler = new CompletionHandler(); final IProgressMonitor[] monitors = new IProgressMonitor[1]; CompletableFuture<Either<List<CompletionItem>, CompletionList>> result = computeAsync((cc) -> { monitors[0] = toMonitor(cc); if (Boolean.getBoolean(JAVA_LSP_JOIN_ON_COMPLETION)) { try { Job.getJobManager().join(DocumentLifeCycleHandler.DOCUMENT_LIFE_CYCLE_JOBS, monitors[0]); } catch (OperationCanceledException ignorable) { // No need to pollute logs when query is cancelled } catch (InterruptedException e) { JavaLanguageServerPlugin.logException(e.getMessage(), e); } } return handler.completion(position, monitors[0]); }); result.join(); if (monitors[0].isCanceled()) { result.cancel(true); } return result; }
protected String _toExpectation(final Either<?, ?> either) { StringConcatenation _builder = new StringConcatenation(); { boolean _isLeft = either.isLeft(); if (_isLeft) { String _expectation = this.toExpectation(either.getLeft()); _builder.append(_expectation); _builder.newLineIfNotEmpty(); } else { String _expectation_1 = this.toExpectation(either.getRight()); _builder.append(_expectation_1); _builder.newLineIfNotEmpty(); } } return _builder.toString(); }
protected Either<List<CompletionItem>, CompletionList> completion(final CancelIndicator origialCancelIndicator, final TextDocumentPositionParams params) { final LanguageServerImpl.BufferedCancelIndicator cancelIndicator = new LanguageServerImpl.BufferedCancelIndicator(origialCancelIndicator); final URI uri = this._uriExtensions.toUri(params.getTextDocument().getUri()); final IResourceServiceProvider resourceServiceProvider = this.languagesRegistry.getResourceServiceProvider(uri); ContentAssistService _get = null; if (resourceServiceProvider!=null) { _get=resourceServiceProvider.<ContentAssistService>get(ContentAssistService.class); } final ContentAssistService contentAssistService = _get; if ((contentAssistService == null)) { CompletionList _completionList = new CompletionList(); return Either.<List<CompletionItem>, CompletionList>forRight(_completionList); } final Function2<Document, XtextResource, CompletionList> _function = (Document document, XtextResource resource) -> { return contentAssistService.createCompletionList(document, resource, params, cancelIndicator); }; final CompletionList completionList = this.workspaceManager.<CompletionList>doRead(uri, _function); return Either.<List<CompletionItem>, CompletionList>forRight(completionList); }
@Test public void testRequest() throws Exception { TextDocumentPositionParams p = new TextDocumentPositionParams(); p.setPosition(new Position(1,1)); p.setTextDocument(new TextDocumentIdentifier("test/foo.txt")); CompletionList result = new CompletionList(); result.setIsIncomplete(true); result.setItems(new ArrayList<>()); CompletionItem item = new CompletionItem(); item.setDetail("test"); item.setDocumentation("doc"); item.setFilterText("filter"); item.setInsertText("insert"); item.setKind(CompletionItemKind.Field); result.getItems().add(item); server.expectedRequests.put("textDocument/completion", new Pair<>(p, result)); CompletableFuture<Either<List<CompletionItem>, CompletionList>> future = clientLauncher.getRemoteProxy().getTextDocumentService().completion(p); Assert.assertEquals(Either.forRight(result).toString(), future.get(TIMEOUT, TimeUnit.MILLISECONDS).toString()); client.joinOnEmpty(); }
@SuppressWarnings({ "unchecked" }) @Test public void testEither_02() { Map<String, JsonRpcMethod> supportedMethods = new LinkedHashMap<>(); supportedMethods.put("foo", JsonRpcMethod.request("foo", new TypeToken<Either<Integer, Map<String,String>>>() {}.getType(), new TypeToken<Object>() {}.getType())); DebugMessageJsonHandler handler = new DebugMessageJsonHandler(supportedMethods); handler.setMethodProvider((id) -> "foo"); Message message = handler.parseMessage("{" + "\"seq\":2,\n" + "\"type\":\"response\",\n" + "\"body\": 2\n" + "}"); Either<Integer, List<Map<String, String>>> result = (Either<Integer, List<Map<String,String>>>) ((ResponseMessage)message).getResult(); Assert.assertTrue(result.isLeft()); Assert.assertEquals(Integer.valueOf(2), result.getLeft()); }
@SuppressWarnings({ "unchecked" }) @Test public void testEither_02() { Map<String, JsonRpcMethod> supportedMethods = new LinkedHashMap<>(); supportedMethods.put("foo", JsonRpcMethod.request("foo", new TypeToken<Either<MyEnum, Map<String,String>>>() {}.getType(), new TypeToken<Object>() {}.getType())); MessageJsonHandler handler = new MessageJsonHandler(supportedMethods); handler.setMethodProvider((id) -> "foo"); Message message = handler.parseMessage("{\"jsonrpc\":\"2.0\"," + "\"id\":\"2\",\n" + "\"result\": 2\n" + "}"); Either<MyEnum, List<Map<String, String>>> result = (Either<MyEnum, List<Map<String,String>>>) ((ResponseMessage)message).getResult(); Assert.assertTrue(result.isLeft()); Assert.assertEquals(MyEnum.B, result.getLeft()); }
private void generateToJson( String indent, PrintWriter out, String varName, String valueAccess, Type paramType) { if (List.class.isAssignableFrom(getRawClass(paramType))) { new ListConverter(varName, valueAccess, paramType).generateListConversion(indent, out); } else if (Map.class.isAssignableFrom(getRawClass(paramType))) { generateMapConversion(indent, out, varName, valueAccess, paramType); } else if (Either.class.isAssignableFrom(getRawClass(paramType))) { generateEitherConversion(indent, out, varName, valueAccess, paramType); } else { out.println( String.format( indent + "%1$s %2$s = %3$s;", json.element(), varName, jsonValueExpression(getRawClass(paramType), valueAccess))); } }
private void generateFromJson( String indent, PrintWriter out, String varName, String valueAccess, Type paramType) { if (List.class.isAssignableFrom(getRawClass(paramType))) { generateListConversion(indent, out, varName, valueAccess, paramType); } else if (Map.class.isAssignableFrom(getRawClass(paramType))) { generateMapConversion(indent, out, varName, valueAccess, paramType); } else if (Either.class.isAssignableFrom(getRawClass(paramType))) { generateEitherConversion(indent, out, varName, valueAccess, paramType); } else { out.println( indent + String.format( "%1$s %2$s = %3$s;", getRawClass(paramType).getName(), varName, fromJsonConversion(getRawClass(paramType), valueAccess))); } }
private void generateToDto( String indent, PrintWriter out, String varName, String valueAccess, Type paramType) { Class<?> rawClass = getRawClass(paramType); if (List.class.isAssignableFrom(rawClass)) { generateListConversion(indent + INDENT, out, varName, valueAccess, paramType); } else if (Map.class.isAssignableFrom(rawClass)) { generateMapConversion(indent + INDENT, out, varName, valueAccess, paramType); } else if (Either.class.isAssignableFrom(rawClass)) { generateEitherConversion(indent + INDENT, out, varName, valueAccess, paramType); } else { out.println( String.format( indent + "%1$s %2$s = %3$s;", rawClass.getName(), varName, dtoValueExpression(rawClass, valueAccess))); } }
@Inject public LanguageServerReconcileStrategy( TextDocumentSynchronizeFactory synchronizeFactory, @Assisted ServerCapabilities serverCapabilities) { Either<TextDocumentSyncKind, TextDocumentSyncOptions> sync = serverCapabilities.getTextDocumentSync(); TextDocumentSyncKind documentSync; if (sync.isLeft()) { documentSync = sync.getLeft(); } else { documentSync = sync.getRight().getChange(); } synchronize = synchronizeFactory.getSynchronize(documentSync); }
@Override public Hover apply(CamelCatalog camelCatalog) { Hover hover = new Hover(); ComponentModel componentModel = ModelHelper.generateComponentModel(camelCatalog.componentJSonSchema(componentName), true); hover.setContents(Collections.singletonList((Either.forLeft(componentModel.getDescription())))); return hover; }
@Test public void testProvideCompletionForCamelBlueprintNamespace() throws Exception { CamelLanguageServer camelLanguageServer = initializeLanguageServer("<from uri=\"\" xmlns=\"http://camel.apache.org/schema/blueprint\"></from>\n"); CompletableFuture<Either<List<CompletionItem>, CompletionList>> completions = getCompletionFor(camelLanguageServer, new Position(0, 11)); assertThat(completions.get().getLeft()).contains(expectedAhcCompletioncompletionItem); }
@Test public void testProvideCompletionForToCamelBlueprintNamespace() throws Exception { CamelLanguageServer camelLanguageServer = initializeLanguageServer("<to uri=\"\" xmlns=\"http://camel.apache.org/schema/blueprint\"></to>\n"); CompletableFuture<Either<List<CompletionItem>, CompletionList>> completions = getCompletionFor(camelLanguageServer, new Position(0, 9)); assertThat(completions.get().getLeft()).contains(expectedAhcCompletioncompletionItem); }
@Test public void testProvideCompletionForCamelSpringNamespace() throws Exception { CamelLanguageServer camelLanguageServer = initializeLanguageServer("<from uri=\"\" xmlns=\"http://camel.apache.org/schema/spring\"></from>\n"); CompletableFuture<Either<List<CompletionItem>, CompletionList>> completions = getCompletionFor(camelLanguageServer, new Position(0, 11)); assertThat(completions.get().getLeft()).contains(expectedAhcCompletioncompletionItem); }
@Test public void testProvideCompletionforMultiline() throws Exception { CamelLanguageServer camelLanguageServer = initializeLanguageServer( "<camelContext xmlns=\"http://camel.apache.org/schema/spring\">\n" + "<to uri=\"\" ></to>\n" + "</camelContext>"); CompletableFuture<Either<List<CompletionItem>, CompletionList>> completions = getCompletionFor(camelLanguageServer, new Position(1, 9)); assertThat(completions.get().getLeft()).contains(expectedAhcCompletioncompletionItem); }
@Test public void testDONTProvideCompletionForNotCamelnamespace() throws Exception { CamelLanguageServer camelLanguageServer = initializeLanguageServer("<from uri=\"\"></from>\n"); CompletableFuture<Either<List<CompletionItem>, CompletionList>> completions = getCompletionFor(camelLanguageServer, new Position(0, 11)); assertThat(completions.get().getLeft()).isEmpty(); assertThat(completions.get().getRight()).isNull(); }
@Test public void testDONTProvideCompletionWhenNotAfterURIEqualQuote() throws Exception { CamelLanguageServer camelLanguageServer = initializeLanguageServer("<from uri=\"\" xmlns=\"http://camel.apache.org/schema/spring\"></from>\n"); CompletableFuture<Either<List<CompletionItem>, CompletionList>> completions = getCompletionFor(camelLanguageServer, new Position(0, 6)); assertThat(completions.get().getLeft()).isEmpty(); assertThat(completions.get().getRight()).isNull(); }
private void testProvideCamelOptions(String textTotest, int line, int character) throws URISyntaxException, InterruptedException, ExecutionException { CamelLanguageServer camelLanguageServer = initializeLanguageServer(textTotest); CompletableFuture<Either<List<CompletionItem>, CompletionList>> completions = getCompletionFor(camelLanguageServer, new Position(line, character)); assertThat(completions.get().getLeft()).contains( new CompletionItem("true"), new CompletionItem("false")); }
@Test public void testProvideCompletionForCamelBlueprintNamespace() throws Exception { CamelLanguageServer camelLanguageServer = initializeLanguageServer(textToTest); CompletableFuture<Either<List<CompletionItem>, CompletionList>> completions = getCompletionFor(camelLanguageServer, new Position(line, character)); if(shouldHaveCompletion) { assertThat(completions.get().getLeft()).contains(expectedAhcCompletioncompletionItem); } else { assertThat(completions.get().getLeft()).doesNotContain(expectedAhcCompletioncompletionItem); assertThat(completions.get().getRight()).isNull(); } }
private void testProvideCamelOptions(String textTotest, int line, int character) throws URISyntaxException, InterruptedException, ExecutionException { CamelLanguageServer camelLanguageServer = initializeLanguageServer(textTotest); CompletableFuture<Either<List<CompletionItem>, CompletionList>> completions = getCompletionFor(camelLanguageServer, new Position(line, character)); assertThat(completions.get().getLeft()).contains( new CompletionItem("InOnly"), new CompletionItem("RobustInOnly"), new CompletionItem("InOut"), new CompletionItem("InOptionalOut"), new CompletionItem("OutOnly"), new CompletionItem("RobustOutOnly"), new CompletionItem("OutIn"), new CompletionItem("OutOptionalIn")); }
protected CompletableFuture<Either<List<CompletionItem>, CompletionList>> getCompletionFor(CamelLanguageServer camelLanguageServer, Position position) { TextDocumentService textDocumentService = camelLanguageServer.getTextDocumentService(); TextDocumentPositionParams dummyCompletionPositionRequest = new TextDocumentPositionParams(new TextDocumentIdentifier(DUMMY_URI), position); CompletableFuture<Either<List<CompletionItem>, CompletionList>> completions = textDocumentService.completion(dummyCompletionPositionRequest); return completions; }
@SuppressWarnings({ "unchecked" }) @Test public void testEither_01() { Map<String, JsonRpcMethod> supportedMethods = new LinkedHashMap<>(); supportedMethods.put("foo", JsonRpcMethod.request("foo", new TypeToken<Either<String, List<Map<String,String>>>>() {}.getType(), new TypeToken<Either<String, Integer>>() {}.getType())); DebugMessageJsonHandler handler = new DebugMessageJsonHandler(supportedMethods); handler.setMethodProvider((id) -> "foo"); Message message = handler.parseMessage("{" + "\"seq\":2,\n" + "\"type\":\"response\",\n" + " \"body\": [\n" + " {\"name\":\"foo\"},\n" + " {\"name\":\"bar\"}\n" + "]}"); Either<String, List<Map<String, String>>> result = (Either<String, List<Map<String,String>>>) ((ResponseMessage)message).getResult(); Assert.assertTrue(result.isRight()); for (Map<String, String> e : result.getRight()) { Assert.assertNotNull(e.get("name")); } message = handler.parseMessage("{" + "\"seq\":2,\n" + "\"type\":\"response\",\n" + "\"body\": \"name\"\n" + "}"); result = (Either<String, List<Map<String,String>>>) ((ResponseMessage)message).getResult(); Assert.assertFalse(result.isRight()); Assert.assertEquals("name",result.getLeft()); }
@SuppressWarnings({ "unchecked" }) @Test public void testEither_04() { Map<String, JsonRpcMethod> supportedMethods = new LinkedHashMap<>(); supportedMethods.put("foo", JsonRpcMethod.request("foo", new TypeToken<Either<MyClass, List<? extends MyClass>>>() {}.getType(), new TypeToken<Object>() {}.getType())); DebugMessageJsonHandler handler = new DebugMessageJsonHandler(supportedMethods); handler.setMethodProvider((id) -> "foo"); Message message = handler.parseMessage("{" + "\"seq\":2,\n" + "\"type\":\"response\",\n" + "\"body\": {\n" + " value:\"foo\"\n" + "}}"); Either<MyClass, List<? extends MyClass>> result = (Either<MyClass, List<? extends MyClass>>) ((ResponseMessage)message).getResult(); Assert.assertTrue(result.isLeft()); Assert.assertEquals("foo", result.getLeft().getValue()); message = handler.parseMessage("{" + "\"seq\":2,\n" + "\"type\":\"response\",\n" + "\"body\": [{\n" + " value:\"bar\"\n" + "}]}"); result = (Either<MyClass, List<? extends MyClass>>) ((ResponseMessage)message).getResult(); Assert.assertTrue(result.isRight()); Assert.assertEquals("bar", result.getRight().get(0).getValue()); }
@SuppressWarnings({ "unchecked" }) @Test public void testEither_05() { Map<String, JsonRpcMethod> supportedMethods = new LinkedHashMap<>(); supportedMethods.put("foo", JsonRpcMethod.request("foo", new TypeToken<Either<List<MyClass>, MyClassList>>() {}.getType(), new TypeToken<Object>() {}.getType())); DebugMessageJsonHandler handler = new DebugMessageJsonHandler(supportedMethods); handler.setMethodProvider((id) -> "foo"); Message message = handler.parseMessage("{" + "\"seq\":2,\n" + "\"type\":\"response\",\n" + "\"body\": [{\n" + " value:\"foo\"\n" + "}]}"); Either<List<MyClass>, MyClassList> result = (Either<List<MyClass>, MyClassList>) ((ResponseMessage)message).getResult(); Assert.assertTrue(result.isLeft()); Assert.assertEquals("foo", result.getLeft().get(0).getValue()); message = handler.parseMessage("{" + "\"seq\":2,\n" + "\"type\":\"response\",\n" + "\"body\": {\n" + " items: [{\n" + " value:\"bar\"\n" + "}]}}"); result = (Either<List<MyClass>, MyClassList>) ((ResponseMessage)message).getResult(); Assert.assertTrue(result.isRight()); Assert.assertEquals("bar", result.getRight().getItems().get(0).getValue()); }
@Override public CompletableFuture<Either<List<CompletionItem>, CompletionList>> completion( TextDocumentPositionParams position) { Instant started = Instant.now(); URI uri = URI.create(position.getTextDocument().getUri()); Optional<String> content = activeContent(uri); int line = position.getPosition().getLine() + 1; int character = position.getPosition().getCharacter() + 1; LOG.info(String.format("completion at %s %d:%d", uri, line, character)); Configured config = server.configured(); FocusedResult result = config.compiler.compileFocused(uri, content, line, character, true); List<CompletionItem> items = Completions.at(result, config.index, config.docs) .limit(server.maxItems) .collect(Collectors.toList()); CompletionList list = new CompletionList(items.size() == server.maxItems, items); Duration elapsed = Duration.between(started, Instant.now()); if (list.isIncomplete()) LOG.info( String.format( "Found %d items (incomplete) in %d ms", items.size(), elapsed.toMillis())); else LOG.info(String.format("Found %d items in %d ms", items.size(), elapsed.toMillis())); return CompletableFuture.completedFuture(Either.forRight(list)); }
public static Hover hoverText(Element el, Javadocs docs) { Optional<String> doc = docs.doc(el).map(Hovers::commentText).map(Javadocs::htmlToMarkdown); String sig = signature(el); String result = doc.map(text -> String.format("```java\n%s\n```\n%s", sig, text)).orElse(sig); return new Hover(Collections.singletonList(Either.forLeft(result)), null); }
@Override public CompletableFuture<Either<List<CompletionItem>, CompletionList>> completion( final TextDocumentPositionParams position) { CompletionList result = som.getCompletions( position.getTextDocument().getUri(), position.getPosition().getLine(), position.getPosition().getCharacter()); return CompletableFuture.completedFuture(Either.forRight(result)); }
/** * Test whether the given type is Either. */ public static boolean isEither(Type type) { if (type instanceof ParameterizedType) { return isEither(((ParameterizedType) type).getRawType()); } if (type instanceof Class) { return Either.class.isAssignableFrom((Class<?>) type); } return false; }
@Override public void write(JsonWriter out, Either<L, R> value) throws IOException { if (value == null) { out.nullValue(); } else if (value.isLeft()) { left.write(out, value.getLeft()); } else { right.write(out, value.getRight()); } }
@Override public Either<L, R> read(JsonReader in) throws IOException { JsonToken next = in.peek(); if (next == JsonToken.NULL) { return null; } Either<L, R> result = create(next, in); if (result == null) throw new IOException("Unexpected token " + next + ", expected " + left + " | " + right + " tokens."); return result; }
public Hover hover(TextDocumentPositionParams position, IProgressMonitor monitor) { ITypeRoot unit = JDTUtils.resolveTypeRoot(position.getTextDocument().getUri()); List<Either<String, MarkedString>> content = null; if (unit != null && !monitor.isCanceled()) { content = computeHover(unit, position.getPosition().getLine(), position.getPosition().getCharacter(), monitor); } Hover $ = new Hover(); $.setContents(content); return $; }
@Test public void testWillSaveAndWillSaveWaitUntilCapabilities() throws Exception { ClientPreferences mockCapabilies = mock(ClientPreferences.class); when(mockCapabilies.isExecuteCommandDynamicRegistrationSupported()).thenReturn(Boolean.TRUE); when(preferenceManager.getClientPreferences()).thenReturn(mockCapabilies); when(mockCapabilies.isWillSaveRegistered()).thenReturn(Boolean.TRUE); when(mockCapabilies.isWillSaveWaitUntilRegistered()).thenReturn(Boolean.TRUE); InitializeResult result = initialize(true); Either<TextDocumentSyncKind, TextDocumentSyncOptions> o = result.getCapabilities().getTextDocumentSync(); assertTrue(o.isRight()); assertTrue(o.getRight().getWillSave()); assertTrue(o.getRight().getWillSaveWaitUntil()); }
@Override public CompletableFuture<Either<List<CompletionItem>, CompletionList>> completion(final TextDocumentPositionParams params) { final Function1<CancelIndicator, Either<List<CompletionItem>, CompletionList>> _function = (CancelIndicator origialCancelIndicator) -> { return this.completion(origialCancelIndicator, params); }; return this.requestManager.<Either<List<CompletionItem>, CompletionList>>runRead(_function); }
protected Hover hover(final HoverContext context) { if ((context == null)) { return IHoverService.EMPTY_HOVER; } final List<Either<String, MarkedString>> contents = this.getContents(context); if ((contents == null)) { return IHoverService.EMPTY_HOVER; } final Range range = this.getRange(context); if ((range == null)) { return IHoverService.EMPTY_HOVER; } return new Hover(contents, range); }