Examples with ExecuteCommandOptions org.eclipse.lsp4j.ExecuteCommandOptions used on opensource projects

Example 1 with ExecuteCommandOptions

use of org.eclipse.lsp4j.ExecuteCommandOptions in project sts4 by spring-projects.

the class SimpleLanguageServer method getServerCapabilities.

protected final ServerCapabilities getServerCapabilities() {
    ServerCapabilities c = new ServerCapabilities();
    c.setTextDocumentSync(TextDocumentSyncKind.Incremental);
    c.setHoverProvider(true);
    CompletionOptions completionProvider = new CompletionOptions();
    completionProvider.setResolveProvider(hasLazyCompletionResolver());
    c.setCompletionProvider(completionProvider);
    if (hasQuickFixes()) {
        c.setCodeActionProvider(true);
    }
    if (hasDefinitionHandler()) {
        c.setDefinitionProvider(true);
    }
    if (hasReferencesHandler()) {
        c.setReferencesProvider(true);
    }
    if (hasDocumentSymbolHandler()) {
        c.setDocumentSymbolProvider(true);
    }
    if (hasDocumentHighlightHandler()) {
        c.setDocumentHighlightProvider(true);
    }
    if (hasCodeLensHandler()) {
        CodeLensOptions codeLensOptions = new CodeLensOptions();
        codeLensOptions.setResolveProvider(hasCodeLensResolveProvider());
        c.setCodeLensProvider(codeLensOptions);
    }
    if (hasExecuteCommandSupport && hasQuickFixes()) {
        c.setExecuteCommandProvider(new ExecuteCommandOptions(ImmutableList.of(CODE_ACTION_COMMAND_ID)));
    }
    if (hasWorkspaceSymbolHandler()) {
        c.setWorkspaceSymbolProvider(true);
    }
    WorkspaceFoldersOptions workspaceFoldersOptions = new WorkspaceFoldersOptions();
    workspaceFoldersOptions.setSupported(true);
    workspaceFoldersOptions.setChangeNotifications(WORKSPACE_FOLDERS_CAPABILITY_ID);
    WorkspaceServerCapabilities workspaceServerCapabilities = new WorkspaceServerCapabilities();
    workspaceServerCapabilities.setWorkspaceFolders(workspaceFoldersOptions);
    c.setWorkspace(workspaceServerCapabilities);
    return c;
}

Example 2 with ExecuteCommandOptions

use of org.eclipse.lsp4j.ExecuteCommandOptions in project sonarlint-core by SonarSource.

the class SonarLintLanguageServer method initialize.

@Override
public CompletableFuture<InitializeResult> initialize(InitializeParams params) {
    String rootUri = params.getRootUri();
    // rootURI is null when no folder is open (like opening a single file in VSCode)
    if (rootUri != null) {
        try {
            workspaceRoot = new URI(rootUri);
        } catch (URISyntaxException e) {
            throw new IllegalStateException(e);
        }
    }
    Map<String, Object> options = (Map<String, Object>) params.getInitializationOptions();
    userSettings = new UserSettings(options);
    String productKey = (String) options.get("productKey");
    // deprecated, will be ignored when productKey present
    String telemetryStorage = (String) options.get("telemetryStorage");
    String productName = (String) options.get("productName");
    String productVersion = (String) options.get("productVersion");
    telemetry.init(getStoragePath(productKey, telemetryStorage), productName, productVersion);
    telemetry.optOut(userSettings.disableTelemetry);
    info("Starting SonarLint engine...");
    info("Using " + analyzers.size() + " analyzers");
    try {
        Map<String, String> extraProperties = new HashMap<>();
        extraProperties.put("sonar.typescript.internal.typescriptLocation", (String) options.get(TYPESCRIPT_LOCATION));
        Builder builder = StandaloneGlobalConfiguration.builder().setLogOutput(logOutput).setExtraProperties(extraProperties).addPlugins(analyzers.toArray(new URL[0]));
        this.engine = new StandaloneSonarLintEngineImpl(builder.build());
    } catch (Exception e) {
        error("Error starting SonarLint engine", e);
        throw new IllegalStateException(e);
    }
    info("SonarLint engine started");
    InitializeResult result = new InitializeResult();
    ServerCapabilities c = new ServerCapabilities();
    TextDocumentSyncOptions textDocumentSyncOptions = new TextDocumentSyncOptions();
    textDocumentSyncOptions.setOpenClose(true);
    textDocumentSyncOptions.setChange(TextDocumentSyncKind.Full);
    textDocumentSyncOptions.setSave(new SaveOptions(true));
    c.setTextDocumentSync(textDocumentSyncOptions);
    c.setCodeActionProvider(true);
    c.setExecuteCommandProvider(new ExecuteCommandOptions(asList(SONARLINT_OPEN_RULE_DESCRIPTION_COMMAND)));
    result.setCapabilities(c);
    return CompletableFuture.completedFuture(result);
}

Example 3 with ExecuteCommandOptions

use of org.eclipse.lsp4j.ExecuteCommandOptions in project xtext-core by eclipse.

the class LanguageServerImpl method initialize.

@Override
public CompletableFuture<InitializeResult> initialize(final InitializeParams params) {
    if ((this.params != null)) {
        throw new IllegalStateException("This language server has already been initialized.");
    }
    final URI baseDir = this.getBaseDir(params);
    boolean _isEmpty = this.languagesRegistry.getExtensionToFactoryMap().isEmpty();
    if (_isEmpty) {
        throw new IllegalStateException("No Xtext languages have been registered. Please make sure you have added the languages\'s setup class in \'/META-INF/services/org.eclipse.xtext.ISetup\'");
    }
    this.params = params;
    final InitializeResult result = new InitializeResult();
    ServerCapabilities _serverCapabilities = new ServerCapabilities();
    final Procedure1<ServerCapabilities> _function = (ServerCapabilities it) -> {
        it.setHoverProvider(Boolean.valueOf(true));
        it.setDefinitionProvider(Boolean.valueOf(true));
        it.setReferencesProvider(Boolean.valueOf(true));
        it.setDocumentSymbolProvider(Boolean.valueOf(true));
        it.setWorkspaceSymbolProvider(Boolean.valueOf(true));
        final Function1<IResourceServiceProvider, Boolean> _function_1 = (IResourceServiceProvider it_1) -> {
            ICodeLensService _get = it_1.<ICodeLensService>get(ICodeLensService.class);
            return Boolean.valueOf((_get != null));
        };
        boolean _exists = IterableExtensions.exists(this.getAllLanguages(), _function_1);
        if (_exists) {
            CodeLensOptions _codeLensOptions = new CodeLensOptions();
            final Procedure1<CodeLensOptions> _function_2 = (CodeLensOptions it_1) -> {
                final Function1<IResourceServiceProvider, Boolean> _function_3 = (IResourceServiceProvider it_2) -> {
                    ICodeLensResolver _get = it_2.<ICodeLensResolver>get(ICodeLensResolver.class);
                    return Boolean.valueOf((_get != null));
                };
                it_1.setResolveProvider(IterableExtensions.exists(this.getAllLanguages(), _function_3));
            };
            CodeLensOptions _doubleArrow = ObjectExtensions.<CodeLensOptions>operator_doubleArrow(_codeLensOptions, _function_2);
            it.setCodeLensProvider(_doubleArrow);
        }
        final Function1<IResourceServiceProvider, Boolean> _function_3 = (IResourceServiceProvider it_1) -> {
            ICodeActionService _get = it_1.<ICodeActionService>get(ICodeActionService.class);
            return Boolean.valueOf((_get != null));
        };
        it.setCodeActionProvider(Boolean.valueOf(IterableExtensions.exists(this.getAllLanguages(), _function_3)));
        SignatureHelpOptions _signatureHelpOptions = new SignatureHelpOptions(Collections.<String>unmodifiableList(CollectionLiterals.<String>newArrayList("(", ",")));
        it.setSignatureHelpProvider(_signatureHelpOptions);
        it.setTextDocumentSync(TextDocumentSyncKind.Incremental);
        CompletionOptions _completionOptions = new CompletionOptions();
        final Procedure1<CompletionOptions> _function_4 = (CompletionOptions it_1) -> {
            it_1.setResolveProvider(Boolean.valueOf(false));
            it_1.setTriggerCharacters(Collections.<String>unmodifiableList(CollectionLiterals.<String>newArrayList(".")));
        };
        CompletionOptions _doubleArrow_1 = ObjectExtensions.<CompletionOptions>operator_doubleArrow(_completionOptions, _function_4);
        it.setCompletionProvider(_doubleArrow_1);
        it.setDocumentFormattingProvider(Boolean.valueOf(true));
        it.setDocumentRangeFormattingProvider(Boolean.valueOf(true));
        it.setDocumentHighlightProvider(Boolean.valueOf(true));
        final Function1<IResourceServiceProvider, Boolean> _function_5 = (IResourceServiceProvider it_1) -> {
            IRenameService _get = it_1.<IRenameService>get(IRenameService.class);
            return Boolean.valueOf((_get != null));
        };
        it.setRenameProvider(Boolean.valueOf(IterableExtensions.exists(this.getAllLanguages(), _function_5)));
        ClientCapabilities _capabilities = params.getCapabilities();
        WorkspaceClientCapabilities _workspace = null;
        if (_capabilities != null) {
            _workspace = _capabilities.getWorkspace();
        }
        ExecuteCommandCapabilities _executeCommand = null;
        if (_workspace != null) {
            _executeCommand = _workspace.getExecuteCommand();
        }
        boolean _tripleNotEquals = (_executeCommand != null);
        if (_tripleNotEquals) {
            this.commandRegistry.initialize(this.getAllLanguages(), params.getCapabilities(), this.client);
            ExecuteCommandOptions _executeCommandOptions = new ExecuteCommandOptions();
            final Procedure1<ExecuteCommandOptions> _function_6 = (ExecuteCommandOptions it_1) -> {
                it_1.setCommands(this.commandRegistry.getCommands());
            };
            ExecuteCommandOptions _doubleArrow_2 = ObjectExtensions.<ExecuteCommandOptions>operator_doubleArrow(_executeCommandOptions, _function_6);
            it.setExecuteCommandProvider(_doubleArrow_2);
        }
    };
    ServerCapabilities capabilities = ObjectExtensions.<ServerCapabilities>operator_doubleArrow(_serverCapabilities, _function);
    Iterable<? extends IResourceServiceProvider> _allLanguages = this.getAllLanguages();
    for (final IResourceServiceProvider language : _allLanguages) {
        ICapabilitiesContributor _get = language.<ICapabilitiesContributor>get(ICapabilitiesContributor.class);
        if (_get != null) {
            _get.contribute(capabilities, params);
        }
    }
    result.setCapabilities(capabilities);
    this.access.addBuildListener(this);
    final Function0<Object> _function_1 = () -> {
        final Procedure2<URI, Iterable<Issue>> _function_2 = (URI $0, Iterable<Issue> $1) -> {
            this.publishDiagnostics($0, $1);
        };
        this.workspaceManager.initialize(baseDir, _function_2, CancelIndicator.NullImpl);
        return null;
    };
    final Function2<CancelIndicator, Object, Object> _function_2 = (CancelIndicator $0, Object $1) -> {
        return null;
    };
    final Function<Object, InitializeResult> _function_3 = (Object it) -> {
        return result;
    };
    return this.requestManager.<Object, Object>runWrite(_function_1, _function_2).<InitializeResult>thenApply(_function_3);
}

Example 4 with ExecuteCommandOptions

use of org.eclipse.lsp4j.ExecuteCommandOptions in project xtext-core by eclipse.

the class ExecutableCommandRegistry method register.

protected IDisposable register(final String command, final IExecutableCommandService service) {
    final String requestId = UUID.randomUUID().toString();
    Registration _registration = new Registration();
    final Procedure1<Registration> _function = (Registration it) -> {
        it.setId(requestId);
        it.setMethod(ExecutableCommandRegistry.METHOD);
        ExecuteCommandOptions _executeCommandOptions = new ExecuteCommandOptions();
        final Procedure1<ExecuteCommandOptions> _function_1 = (ExecuteCommandOptions it_1) -> {
            it_1.setCommands(Collections.<String>unmodifiableList(CollectionLiterals.<String>newArrayList(command)));
        };
        ExecuteCommandOptions _doubleArrow = ObjectExtensions.<ExecuteCommandOptions>operator_doubleArrow(_executeCommandOptions, _function_1);
        it.setRegisterOptions(_doubleArrow);
    };
    final Registration reg = ObjectExtensions.<Registration>operator_doubleArrow(_registration, _function);
    RegistrationParams _registrationParams = new RegistrationParams();
    final Procedure1<RegistrationParams> _function_1 = (RegistrationParams it) -> {
        it.setRegistrations(CollectionLiterals.<Registration>newArrayList(reg));
    };
    RegistrationParams _doubleArrow = ObjectExtensions.<RegistrationParams>operator_doubleArrow(_registrationParams, _function_1);
    this.client.registerCapability(_doubleArrow);
    this.registeredCommands.put(command, service);
    final IDisposable _function_2 = () -> {
        Unregistration _unregistration = new Unregistration();
        final Procedure1<Unregistration> _function_3 = (Unregistration it) -> {
            it.setId(requestId);
            it.setMethod(ExecutableCommandRegistry.METHOD);
        };
        final Unregistration unReg = ObjectExtensions.<Unregistration>operator_doubleArrow(_unregistration, _function_3);
        UnregistrationParams _unregistrationParams = new UnregistrationParams();
        final Procedure1<UnregistrationParams> _function_4 = (UnregistrationParams it) -> {
            it.setUnregisterations(CollectionLiterals.<Unregistration>newArrayList(unReg));
        };
        UnregistrationParams _doubleArrow_1 = ObjectExtensions.<UnregistrationParams>operator_doubleArrow(_unregistrationParams, _function_4);
        this.client.unregisterCapability(_doubleArrow_1);
        this.registeredCommands.remove(command, service);
    };
    return _function_2;
}

Example 5 with ExecuteCommandOptions

use of org.eclipse.lsp4j.ExecuteCommandOptions in project eclipse.jdt.ls by eclipse.

the class InitHandler method initialize.

@SuppressWarnings("unchecked")
InitializeResult initialize(InitializeParams param) {
    logInfo("Initializing Java Language Server " + JavaLanguageServerPlugin.getVersion());
    Map<?, ?> initializationOptions = this.getInitializationOptions(param);
    Map<String, Object> extendedClientCapabilities = getInitializationOption(initializationOptions, "extendedClientCapabilities", Map.class);
    if (param.getCapabilities() == null) {
        preferenceManager.updateClientPrefences(new ClientCapabilities(), extendedClientCapabilities);
    } else {
        preferenceManager.updateClientPrefences(param.getCapabilities(), extendedClientCapabilities);
    }
    Collection<IPath> rootPaths = new ArrayList<>();
    Collection<String> workspaceFolders = getInitializationOption(initializationOptions, "workspaceFolders", Collection.class);
    if (workspaceFolders != null && !workspaceFolders.isEmpty()) {
        for (String uri : workspaceFolders) {
            IPath filePath = ResourceUtils.filePathFromURI(uri);
            if (filePath != null) {
                rootPaths.add(filePath);
            }
        }
    } else {
        String rootPath = param.getRootUri();
        if (rootPath == null) {
            rootPath = param.getRootPath();
            if (rootPath != null) {
                logInfo("In LSP 3.0, InitializeParams.rootPath is deprecated in favour of InitializeParams.rootUri!");
            }
        }
        if (rootPath != null) {
            IPath filePath = ResourceUtils.filePathFromURI(rootPath);
            if (filePath != null) {
                rootPaths.add(filePath);
            }
        }
    }
    if (rootPaths.isEmpty()) {
        IPath workspaceLocation = ResourcesPlugin.getWorkspace().getRoot().getLocation();
        logInfo("No workspace folders or root uri was defined. Falling back on " + workspaceLocation);
        rootPaths.add(workspaceLocation);
    }
    if (initializationOptions.get(SETTINGS_KEY) instanceof Map) {
        Object settings = initializationOptions.get(SETTINGS_KEY);
        @SuppressWarnings("unchecked") Preferences prefs = Preferences.createFrom((Map<String, Object>) settings);
        preferenceManager.update(prefs);
    }
    triggerInitialization(rootPaths);
    addWorkspaceDiagnosticsHandler();
    Integer processId = param.getProcessId();
    if (processId != null) {
        JavaLanguageServerPlugin.getLanguageServer().setParentProcessId(processId.longValue());
    }
    try {
        Collection<String> bundleList = getInitializationOption(initializationOptions, BUNDLES_KEY, Collection.class);
        BundleUtils.loadBundles(bundleList);
    } catch (CoreException e) {
        // The additional plug-ins should not affect the main language server loading.
        JavaLanguageServerPlugin.logException("Failed to load extension bundles ", e);
    }
    InitializeResult result = new InitializeResult();
    ServerCapabilities capabilities = new ServerCapabilities();
    capabilities.setCompletionProvider(new CompletionOptions(Boolean.TRUE, Arrays.asList(".", "@", "#")));
    if (!preferenceManager.getClientPreferences().isFormattingDynamicRegistrationSupported()) {
        capabilities.setDocumentFormattingProvider(Boolean.TRUE);
    }
    if (!preferenceManager.getClientPreferences().isRangeFormattingDynamicRegistrationSupported()) {
        capabilities.setDocumentRangeFormattingProvider(Boolean.TRUE);
    }
    if (!preferenceManager.getClientPreferences().isCodeLensDynamicRegistrationSupported()) {
        capabilities.setCodeLensProvider(new CodeLensOptions(true));
    }
    if (!preferenceManager.getClientPreferences().isSignatureHelpDynamicRegistrationSupported()) {
        capabilities.setSignatureHelpProvider(SignatureHelpHandler.createOptions());
    }
    if (!preferenceManager.getClientPreferences().isRenameDynamicRegistrationSupported()) {
        capabilities.setRenameProvider(Boolean.TRUE);
    }
    if (!preferenceManager.getClientPreferences().isCodeActionDynamicRegistered()) {
        capabilities.setCodeActionProvider(Boolean.TRUE);
    }
    if (!preferenceManager.getClientPreferences().isExecuteCommandDynamicRegistrationSupported()) {
        Set<String> commands = WorkspaceExecuteCommandHandler.getCommands();
        capabilities.setExecuteCommandProvider(new ExecuteCommandOptions(new ArrayList<>(commands)));
    }
    if (!preferenceManager.getClientPreferences().isWorkspaceSymbolDynamicRegistered()) {
        capabilities.setWorkspaceSymbolProvider(Boolean.TRUE);
    }
    if (!preferenceManager.getClientPreferences().isDocumentSymbolDynamicRegistered()) {
        capabilities.setDocumentSymbolProvider(Boolean.TRUE);
    }
    if (!preferenceManager.getClientPreferences().isDefinitionDynamicRegistered()) {
        capabilities.setDefinitionProvider(Boolean.TRUE);
    }
    if (!preferenceManager.getClientPreferences().isHoverDynamicRegistered()) {
        capabilities.setHoverProvider(Boolean.TRUE);
    }
    if (!preferenceManager.getClientPreferences().isReferencesDynamicRegistered()) {
        capabilities.setReferencesProvider(Boolean.TRUE);
    }
    if (!preferenceManager.getClientPreferences().isDocumentHighlightDynamicRegistered()) {
        capabilities.setDocumentHighlightProvider(Boolean.TRUE);
    }
    TextDocumentSyncOptions textDocumentSyncOptions = new TextDocumentSyncOptions();
    textDocumentSyncOptions.setOpenClose(Boolean.TRUE);
    textDocumentSyncOptions.setSave(new SaveOptions(Boolean.TRUE));
    textDocumentSyncOptions.setChange(TextDocumentSyncKind.Incremental);
    if (preferenceManager.getClientPreferences().isWillSaveRegistered()) {
        textDocumentSyncOptions.setWillSave(Boolean.TRUE);
    }
    if (preferenceManager.getClientPreferences().isWillSaveWaitUntilRegistered()) {
        textDocumentSyncOptions.setWillSaveWaitUntil(Boolean.TRUE);
    }
    capabilities.setTextDocumentSync(textDocumentSyncOptions);
    WorkspaceServerCapabilities wsCapabilities = new WorkspaceServerCapabilities();
    WorkspaceFoldersOptions wsFoldersOptions = new WorkspaceFoldersOptions();
    wsFoldersOptions.setSupported(Boolean.TRUE);
    wsFoldersOptions.setChangeNotifications(Boolean.TRUE);
    wsCapabilities.setWorkspaceFolders(wsFoldersOptions);
    capabilities.setWorkspace(wsCapabilities);
    result.setCapabilities(capabilities);
    return result;
}