org.eclipse.lsp4e/src/org/eclipse/lsp4e/LanguageServersRegistry.java - lsp4e/lsp4e - Git at Google

 /*******************************************************************************
  * Copyright (c) 2016, 2020 Red Hat Inc. and others.
  * This program and the accompanying materials are made
  * available under the terms of the Eclipse Public License 2.0
  * which is available at https://www.eclipse.org/legal/epl-2.0/
  *
  * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *  Mickael Istria (Red Hat Inc.) - initial implementation
  *  Miro Spoenemann (TypeFox) - added clientImpl and serverInterface attributes
  *  Alexander Fedorov (ArSysOp) - added parent context to evaluation
  *******************************************************************************/
 package org.eclipse.lsp4e;

 import java.io.IOException;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Optional;
 import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.stream.Collectors;

 import org.eclipse.core.expressions.ExpressionConverter;
 import org.eclipse.core.expressions.IEvaluationContext;
 import org.eclipse.core.resources.IFile;
 import org.eclipse.core.runtime.CoreException;
 import org.eclipse.core.runtime.IConfigurationElement;
 import org.eclipse.core.runtime.IStatus;
 import org.eclipse.core.runtime.Platform;
 import org.eclipse.core.runtime.Status;
 import org.eclipse.core.runtime.content.IContentType;
 import org.eclipse.debug.core.ILaunchConfiguration;
 import org.eclipse.jdt.annotation.NonNull;
 import org.eclipse.jdt.annotation.Nullable;
 import org.eclipse.jface.preference.IPersistentPreferenceStore;
 import org.eclipse.jface.preference.IPreferenceStore;
 import org.eclipse.jface.text.IDocument;
 import org.eclipse.lsp4e.enablement.EnablementTester;
 import org.eclipse.lsp4e.server.StreamConnectionProvider;
 import org.eclipse.lsp4j.jsonrpc.Launcher;
 import org.eclipse.lsp4j.services.LanguageServer;
 import org.eclipse.ui.IEditorInput;
 import org.eclipse.ui.PlatformUI;
 import org.eclipse.ui.handlers.IHandlerService;
 import org.eclipse.ui.statushandlers.StatusManager;
 import org.osgi.framework.Bundle;

 /**
  * This registry aims at providing a good language server connection (as {@link StreamConnectionProvider}
  * for a given input.
  * At the moment, registry content are hardcoded but we'll very soon need a way
  * to contribute to it via plugin.xml (for plugin developers) and from Preferences
  * (for end-users to directly register a new server).
  *
  */
 public class LanguageServersRegistry {

 	private static final String CONTENT_TYPE_TO_LSP_LAUNCH_PREF_KEY = "contentTypeToLSPLauch"; //$NON-NLS-1$

 	private static final String EXTENSION_POINT_ID = LanguageServerPlugin.PLUGIN_ID + ".languageServer"; //$NON-NLS-1$

 	private static final String LS_ELEMENT = "server"; //$NON-NLS-1$
 	private static final String MAPPING_ELEMENT = "contentTypeMapping"; //$NON-NLS-1$

 	private static final String ID_ATTRIBUTE = "id"; //$NON-NLS-1$
 	private static final String SINGLETON_ATTRIBUTE = "singleton"; //$NON-NLS-1$
 	private static final String CONTENT_TYPE_ATTRIBUTE = "contentType"; //$NON-NLS-1$
 	private static final String LANGUAGE_ID_ATTRIBUTE = "languageId"; //$NON-NLS-1$
 	private static final String CLASS_ATTRIBUTE = "class"; //$NON-NLS-1$
 	private static final String CLIENT_IMPL_ATTRIBUTE = "clientImpl"; //$NON-NLS-1$
 	private static final String SERVER_INTERFACE_ATTRIBUTE = "serverInterface"; //$NON-NLS-1$
 	private static final String LAUNCHER_BUILDER_ATTRIBUTE = "launcherBuilder"; //$NON-NLS-1$
 	private static final String LABEL_ATTRIBUTE = "label"; //$NON-NLS-1$
 	private static final String ENABLED_WHEN_ATTRIBUTE = "enabledWhen"; //$NON-NLS-1$
 	private static final String ENABLED_WHEN_DESC = "description"; //$NON-NLS-1$

 	public abstract static class LanguageServerDefinition {
 		public final @NonNull String id;
 		public final @NonNull String label;
 		public final boolean isSingleton;
 		public final @NonNull Map<IContentType, String> langugeIdMappings;

 		public LanguageServerDefinition(@NonNull String id, @NonNull String label, boolean isSingleton) {
 			this.id = id;
 			this.label = label;
 			this.isSingleton = isSingleton;
 			this.langugeIdMappings = new ConcurrentHashMap<>();
 		}

 		public void registerAssociation(@NonNull IContentType contentType, @NonNull String languageId) {
 			this.langugeIdMappings.put(contentType, languageId);
 		}

 		public abstract StreamConnectionProvider createConnectionProvider();

 		public LanguageClientImpl createLanguageClient() {
 			return new LanguageClientImpl();
 		}

 		public Class<? extends LanguageServer> getServerInterface() {
 			return LanguageServer.class;
 		}

 		public <S extends LanguageServer> Launcher.Builder<S> createLauncherBuilder() {
 			return new Launcher.Builder<S>();
 		}

 	}

 	static class ExtensionLanguageServerDefinition extends LanguageServerDefinition {
 		private IConfigurationElement extension;

 		public ExtensionLanguageServerDefinition(IConfigurationElement element) {
 			super(element.getAttribute(ID_ATTRIBUTE), element.getAttribute(LABEL_ATTRIBUTE), Boolean.parseBoolean(element.getAttribute(SINGLETON_ATTRIBUTE)));
 			this.extension = element;
 		}

 		@Override
 		public StreamConnectionProvider createConnectionProvider() {
 			try {
 				return (StreamConnectionProvider) extension.createExecutableExtension(CLASS_ATTRIBUTE);
 			} catch (CoreException e) {
 				StatusManager.getManager().handle(e, LanguageServerPlugin.PLUGIN_ID);
 				throw new RuntimeException(
 						"Exception occurred while creating an instance of the stream connection provider", e); //$NON-NLS-1$
 			}
 		}

 		@Override
 		public LanguageClientImpl createLanguageClient() {
 			String clientImpl = extension.getAttribute(CLIENT_IMPL_ATTRIBUTE);
 			if (clientImpl != null && !clientImpl.isEmpty()) {
 				try {
 					return (LanguageClientImpl) extension.createExecutableExtension(CLIENT_IMPL_ATTRIBUTE);
 				} catch (CoreException e) {
 					StatusManager.getManager().handle(e, LanguageServerPlugin.PLUGIN_ID);
 				}
 			}
 			return super.createLanguageClient();
 		}

 		@SuppressWarnings("unchecked")
 		@Override
 		public Class<? extends LanguageServer> getServerInterface() {
 			String serverInterface = extension.getAttribute(SERVER_INTERFACE_ATTRIBUTE);
 			if (serverInterface != null && !serverInterface.isEmpty()) {
 				Bundle bundle = Platform.getBundle(extension.getContributor().getName());
 				if (bundle != null) {
 					try {
 						return (Class<? extends LanguageServer>) bundle.loadClass(serverInterface);
 					} catch (ClassNotFoundException exception) {
 						StatusManager.getManager().handle(new Status(IStatus.ERROR, LanguageServerPlugin.PLUGIN_ID,
 								exception.getMessage(), exception));
 					}
 				}
 			}
 			return super.getServerInterface();
 		}

 		@SuppressWarnings("unchecked")
 		@Override
 		public <S extends LanguageServer> Launcher.Builder<S> createLauncherBuilder() {
 			String launcherSupplier = extension.getAttribute(LAUNCHER_BUILDER_ATTRIBUTE);
 			if (launcherSupplier != null && !launcherSupplier.isEmpty()) {
 				try {
 					return (Launcher.Builder<S>) extension.createExecutableExtension(LAUNCHER_BUILDER_ATTRIBUTE);
 				} catch (CoreException e) {
 					StatusManager.getManager().handle(e, LanguageServerPlugin.PLUGIN_ID);
 				}
 			}
 			return super.createLauncherBuilder();
 		}

 	}

 	static class LaunchConfigurationLanguageServerDefinition extends LanguageServerDefinition {
 		final ILaunchConfiguration launchConfiguration;
 		final Set<String> launchModes;

 		public LaunchConfigurationLanguageServerDefinition(ILaunchConfiguration launchConfiguration,
 				Set<String> launchModes) {
 			super(launchConfiguration.getName(), launchConfiguration.getName(), false);
 			this.launchConfiguration = launchConfiguration;
 			this.launchModes = launchModes;
 		}

 		@Override
 		public StreamConnectionProvider createConnectionProvider() {
 			return new LaunchConfigurationStreamProvider(this.launchConfiguration, launchModes);
 		}
 	}

 	private static LanguageServersRegistry INSTANCE = null;
 	public static LanguageServersRegistry getInstance() {
 		if (INSTANCE == null) {
 			INSTANCE = new LanguageServersRegistry();
 		}
 		return INSTANCE;
 	}

 	private List<ContentTypeToLanguageServerDefinition> connections = new ArrayList<>();
 	private IPreferenceStore preferenceStore;

 	private LanguageServersRegistry() {
 		this.preferenceStore = LanguageServerPlugin.getDefault().getPreferenceStore();
 		initialize();
 	}

 	private void initialize() {
 		String prefs = preferenceStore.getString(CONTENT_TYPE_TO_LSP_LAUNCH_PREF_KEY);
 		if (prefs != null && !prefs.isEmpty()) {
 			String[] entries = prefs.split(","); //$NON-NLS-1$
 			for (String entry : entries) {
 				ContentTypeToLSPLaunchConfigEntry mapping = ContentTypeToLSPLaunchConfigEntry.readFromPreference(entry);
 				if (mapping != null) {
 					connections.add(mapping);
 				}
 			}
 		}

 		Map<String, LanguageServerDefinition> servers = new HashMap<>();
 		List<ContentTypeMapping> contentTypes = new ArrayList<>();
 		for (IConfigurationElement extension : Platform.getExtensionRegistry().getConfigurationElementsFor(EXTENSION_POINT_ID)) {
 			String id = extension.getAttribute(ID_ATTRIBUTE);
 			if (id != null && !id.isEmpty()) {
 				if (extension.getName().equals(LS_ELEMENT)) {
 					servers.put(id, new ExtensionLanguageServerDefinition(extension));
 				} else if (extension.getName().equals(MAPPING_ELEMENT)) {
 					IContentType contentType = Platform.getContentTypeManager().getContentType(extension.getAttribute(CONTENT_TYPE_ATTRIBUTE));
 					String languageId = extension.getAttribute(LANGUAGE_ID_ATTRIBUTE);
 					EnablementTester expression = null;
 					if (extension.getChildren(ENABLED_WHEN_ATTRIBUTE) != null) {
 						IConfigurationElement[] enabledWhenElements = extension.getChildren(ENABLED_WHEN_ATTRIBUTE);
 						if (enabledWhenElements.length == 1) {
 							IConfigurationElement enabledWhen = enabledWhenElements[0];
 							IConfigurationElement[] enabledWhenChildren = enabledWhen.getChildren();
 							if (enabledWhenChildren.length == 1) {
 								try {
 									String description = enabledWhen.getAttribute(ENABLED_WHEN_DESC);
 									expression = new EnablementTester(this::evaluationContext,
 											ExpressionConverter.getDefault().perform(enabledWhenChildren[0]),
 											description);
 								} catch (CoreException e) {
 									LanguageServerPlugin.logWarning(e.getMessage(), e);
 								}
 							}
 						}
 					}
 					if (contentType != null) {
 						contentTypes.add(new ContentTypeMapping(contentType, id, languageId, expression));
 					}
 				}
 			}
 		}

 		for (ContentTypeMapping mapping : contentTypes) {
 			LanguageServerDefinition lsDefinition = servers.get(mapping.id);
 			if (lsDefinition != null) {
 				registerAssociation(mapping.contentType, lsDefinition, mapping.languageId, mapping.enablement);
 			} else {
 				LanguageServerPlugin.logWarning("server '" + mapping.id + "' not available", null); //$NON-NLS-1$ //$NON-NLS-2$
 			}
 		}
 	}

 	private IEvaluationContext evaluationContext() {
 		return Optional.ofNullable(PlatformUI.getWorkbench().getService(IHandlerService.class))//
 				.map(IHandlerService::getCurrentState)//
 				.orElse(null);
 	}

 	private void persistContentTypeToLaunchConfigurationMapping() {
 		StringBuilder builder = new StringBuilder();
 		for (ContentTypeToLSPLaunchConfigEntry entry : getContentTypeToLSPLaunches()) {
 			entry.appendPreferenceTo(builder);
 			builder.append(',');
 		}
 		if (builder.length() > 0) {
 			builder.deleteCharAt(builder.length() - 1);
 		}
 		this.preferenceStore.setValue(CONTENT_TYPE_TO_LSP_LAUNCH_PREF_KEY, builder.toString());
 		if (this.preferenceStore instanceof IPersistentPreferenceStore) {
 			try {
 				((IPersistentPreferenceStore) this.preferenceStore).save();
 			} catch (IOException e) {
 				LanguageServerPlugin.logError(e);
 			}
 		}
 	}

 	/**
 	 * @param contentType
 	 * @return the {@link LanguageServerDefinition}s <strong>directly</strong> associated to the given content-type.
 	 * This does <strong>not</strong> include the one that match transitively as per content-type hierarchy
 	 */
 	List<ContentTypeToLanguageServerDefinition> findProviderFor(final @NonNull IContentType contentType) {
 		return connections.stream()
 			.filter(entry -> entry.getKey().equals(contentType))
 			.sorted((mapping1, mapping2) -> {
 				// this sort should make that the content-type hierarchy is respected
 				// and the most specialized content-type are placed before the more generic ones
 				if (mapping1.getKey().isKindOf(mapping2.getKey())) {
 					return -1;
 				} else if (mapping2.getKey().isKindOf(mapping1.getKey())) {
 					return +1;
 				}
 				// TODO support "priority" attribute, but it's not made public
 				return mapping1.getKey().getId().compareTo(mapping2.getKey().getId());
 			})
 			.collect(Collectors.toList());
 	}

 	public void registerAssociation(@NonNull IContentType contentType, @NonNull ILaunchConfiguration launchConfig, @NonNull Set<String> launchMode) {
 		ContentTypeToLSPLaunchConfigEntry mapping = new ContentTypeToLSPLaunchConfigEntry(contentType, launchConfig,
 				launchMode);
 		connections.add(mapping);
 		persistContentTypeToLaunchConfigurationMapping();
 	}

 	public void registerAssociation(@NonNull IContentType contentType,
 			@NonNull LanguageServerDefinition serverDefinition, @Nullable String languageId,
 			EnablementTester enablement) {
 		if (languageId != null) {
 			serverDefinition.registerAssociation(contentType, languageId);
 		}

 		connections.add(new ContentTypeToLanguageServerDefinition(contentType, serverDefinition, enablement));
 	}

 	public void setAssociations(List<ContentTypeToLSPLaunchConfigEntry> wc) {
 		this.connections.removeIf(ContentTypeToLSPLaunchConfigEntry.class::isInstance);
 		this.connections.addAll(wc);
 		persistContentTypeToLaunchConfigurationMapping();
 	}

 	public List<ContentTypeToLSPLaunchConfigEntry> getContentTypeToLSPLaunches() {
 		return this.connections.stream().filter(ContentTypeToLSPLaunchConfigEntry.class::isInstance).map(ContentTypeToLSPLaunchConfigEntry.class::cast).collect(Collectors.toList());
 	}

 	public List<ContentTypeToLanguageServerDefinition> getContentTypeToLSPExtensions() {
 		return this.connections.stream().filter(mapping -> mapping.getValue() instanceof ExtensionLanguageServerDefinition).collect(Collectors.toList());
 	}

 	public @Nullable LanguageServerDefinition getDefinition(@NonNull String languageServerId) {
 		for (ContentTypeToLanguageServerDefinition mapping : this.connections) {
 			if (mapping.getValue().id.equals(languageServerId)) {
 				return mapping.getValue();
 			}
 		}
 		return null;
 	}

 	/**
 	 * internal class to capture content-type mappings for language servers
 	 */
 	private static class ContentTypeMapping {

 		@NonNull public final String id;
 		@NonNull public final IContentType contentType;
 		@Nullable public final String languageId;
 		@Nullable
 		public final EnablementTester enablement;

 		public ContentTypeMapping(@NonNull IContentType contentType, @NonNull String id, @Nullable String languageId,
 				@Nullable EnablementTester enablement) {
 			this.contentType = contentType;
 			this.id = id;
 			this.languageId = languageId;
 			this.enablement = enablement;
 		}

 	}

 	/**
 	 * @param file
 	 * @param serverDefinition
 	 * @return whether the given serverDefinition is suitable for the file
 	 */
 	public boolean matches(@NonNull IFile file, @NonNull LanguageServerDefinition serverDefinition) {
 		return getAvailableLSFor(LSPEclipseUtils.getFileContentTypes(file)).contains(serverDefinition);
 	}

 	/**
 	 * @param document
 	 * @param serverDefinition
 	 * @return whether the given serverDefinition is suitable for the file
 	 */
 	public boolean matches(@NonNull IDocument document, @NonNull LanguageServerDefinition serverDefinition) {
 		return getAvailableLSFor(LSPEclipseUtils.getDocumentContentTypes(document)).contains(serverDefinition);
 	}

 	public boolean canUseLanguageServer(@NonNull IEditorInput editorInput) {
 		return !getAvailableLSFor(
 				Arrays.asList(Platform.getContentTypeManager().findContentTypesFor(editorInput.getName()))).isEmpty();
 	}

 	public boolean canUseLanguageServer(@NonNull IDocument document) {
 		List<IContentType> contentTypes = LSPEclipseUtils.getDocumentContentTypes(document);

 		if (contentTypes.isEmpty()) {
 			return false;
 		}

 		return !getAvailableLSFor(contentTypes).isEmpty();
 	}

 	public boolean canUseLanguageServer(@NonNull IFile file) {
 		return !getAvailableLSFor(LSPEclipseUtils.getFileContentTypes(file)).isEmpty();
 	}

 	private Set<LanguageServerDefinition> getAvailableLSFor(Collection<IContentType> contentTypes) {
 		Set<LanguageServerDefinition> res = new HashSet<>();
 		for (ContentTypeToLanguageServerDefinition mapping : this.connections) {
 			if (mapping.isEnabled() && contentTypes.contains(mapping.getKey())) {
 				res.add(mapping.getValue());
 			}
 		}
 		return res;
 	}

 }
	/*******************************************************************************
	* Copyright (c) 2016, 2020 Red Hat Inc. and others.
	* This program and the accompanying materials are made
	* available under the terms of the Eclipse Public License 2.0
	* which is available at https://www.eclipse.org/legal/epl-2.0/
	*
	* SPDX-License-Identifier: EPL-2.0
	*
	* Contributors:
	* Mickael Istria (Red Hat Inc.) - initial implementation
	* Miro Spoenemann (TypeFox) - added clientImpl and serverInterface attributes
	* Alexander Fedorov (ArSysOp) - added parent context to evaluation
	*******************************************************************************/
	package org.eclipse.lsp4e;

	import java.io.IOException;
	import java.util.ArrayList;
	import java.util.Arrays;
	import java.util.Collection;
	import java.util.HashMap;
	import java.util.HashSet;
	import java.util.List;
	import java.util.Map;
	import java.util.Optional;
	import java.util.Set;
	import java.util.concurrent.ConcurrentHashMap;
	import java.util.stream.Collectors;

	import org.eclipse.core.expressions.ExpressionConverter;
	import org.eclipse.core.expressions.IEvaluationContext;
	import org.eclipse.core.resources.IFile;
	import org.eclipse.core.runtime.CoreException;
	import org.eclipse.core.runtime.IConfigurationElement;
	import org.eclipse.core.runtime.IStatus;
	import org.eclipse.core.runtime.Platform;
	import org.eclipse.core.runtime.Status;
	import org.eclipse.core.runtime.content.IContentType;
	import org.eclipse.debug.core.ILaunchConfiguration;
	import org.eclipse.jdt.annotation.NonNull;
	import org.eclipse.jdt.annotation.Nullable;
	import org.eclipse.jface.preference.IPersistentPreferenceStore;
	import org.eclipse.jface.preference.IPreferenceStore;
	import org.eclipse.jface.text.IDocument;
	import org.eclipse.lsp4e.enablement.EnablementTester;
	import org.eclipse.lsp4e.server.StreamConnectionProvider;
	import org.eclipse.lsp4j.jsonrpc.Launcher;
	import org.eclipse.lsp4j.services.LanguageServer;
	import org.eclipse.ui.IEditorInput;
	import org.eclipse.ui.PlatformUI;
	import org.eclipse.ui.handlers.IHandlerService;
	import org.eclipse.ui.statushandlers.StatusManager;
	import org.osgi.framework.Bundle;

	/**
	* This registry aims at providing a good language server connection (as {@link StreamConnectionProvider}
	* for a given input.
	* At the moment, registry content are hardcoded but we'll very soon need a way
	* to contribute to it via plugin.xml (for plugin developers) and from Preferences
	* (for end-users to directly register a new server).
	*
	*/
	public class LanguageServersRegistry {

	private static final String CONTENT_TYPE_TO_LSP_LAUNCH_PREF_KEY = "contentTypeToLSPLauch"; //$NON-NLS-1$

	private static final String EXTENSION_POINT_ID = LanguageServerPlugin.PLUGIN_ID + ".languageServer"; //$NON-NLS-1$

	private static final String LS_ELEMENT = "server"; //$NON-NLS-1$
	private static final String MAPPING_ELEMENT = "contentTypeMapping"; //$NON-NLS-1$

	private static final String ID_ATTRIBUTE = "id"; //$NON-NLS-1$
	private static final String SINGLETON_ATTRIBUTE = "singleton"; //$NON-NLS-1$
	private static final String CONTENT_TYPE_ATTRIBUTE = "contentType"; //$NON-NLS-1$
	private static final String LANGUAGE_ID_ATTRIBUTE = "languageId"; //$NON-NLS-1$
	private static final String CLASS_ATTRIBUTE = "class"; //$NON-NLS-1$
	private static final String CLIENT_IMPL_ATTRIBUTE = "clientImpl"; //$NON-NLS-1$
	private static final String SERVER_INTERFACE_ATTRIBUTE = "serverInterface"; //$NON-NLS-1$
	private static final String LAUNCHER_BUILDER_ATTRIBUTE = "launcherBuilder"; //$NON-NLS-1$
	private static final String LABEL_ATTRIBUTE = "label"; //$NON-NLS-1$
	private static final String ENABLED_WHEN_ATTRIBUTE = "enabledWhen"; //$NON-NLS-1$
	private static final String ENABLED_WHEN_DESC = "description"; //$NON-NLS-1$

	public abstract static class LanguageServerDefinition {
	public final @NonNull String id;
	public final @NonNull String label;
	public final boolean isSingleton;
	public final @NonNull Map<IContentType, String> langugeIdMappings;

	public LanguageServerDefinition(@NonNull String id, @NonNull String label, boolean isSingleton) {
	this.id = id;
	this.label = label;
	this.isSingleton = isSingleton;
	this.langugeIdMappings = new ConcurrentHashMap<>();
	}

	public void registerAssociation(@NonNull IContentType contentType, @NonNull String languageId) {
	this.langugeIdMappings.put(contentType, languageId);
	}

	public abstract StreamConnectionProvider createConnectionProvider();

	public LanguageClientImpl createLanguageClient() {
	return new LanguageClientImpl();
	}

	public Class<? extends LanguageServer> getServerInterface() {
	return LanguageServer.class;
	}

	public <S extends LanguageServer> Launcher.Builder<S> createLauncherBuilder() {
	return new Launcher.Builder<S>();
	}

	}

	static class ExtensionLanguageServerDefinition extends LanguageServerDefinition {
	private IConfigurationElement extension;

	public ExtensionLanguageServerDefinition(IConfigurationElement element) {
	super(element.getAttribute(ID_ATTRIBUTE), element.getAttribute(LABEL_ATTRIBUTE), Boolean.parseBoolean(element.getAttribute(SINGLETON_ATTRIBUTE)));
	this.extension = element;
	}

	@Override
	public StreamConnectionProvider createConnectionProvider() {
	try {
	return (StreamConnectionProvider) extension.createExecutableExtension(CLASS_ATTRIBUTE);
	} catch (CoreException e) {
	StatusManager.getManager().handle(e, LanguageServerPlugin.PLUGIN_ID);
	throw new RuntimeException(
	"Exception occurred while creating an instance of the stream connection provider", e); //$NON-NLS-1$
	}
	}

	@Override
	public LanguageClientImpl createLanguageClient() {
	String clientImpl = extension.getAttribute(CLIENT_IMPL_ATTRIBUTE);
	if (clientImpl != null && !clientImpl.isEmpty()) {
	try {
	return (LanguageClientImpl) extension.createExecutableExtension(CLIENT_IMPL_ATTRIBUTE);
	} catch (CoreException e) {
	StatusManager.getManager().handle(e, LanguageServerPlugin.PLUGIN_ID);
	}
	}
	return super.createLanguageClient();
	}

	@SuppressWarnings("unchecked")
	@Override
	public Class<? extends LanguageServer> getServerInterface() {
	String serverInterface = extension.getAttribute(SERVER_INTERFACE_ATTRIBUTE);
	if (serverInterface != null && !serverInterface.isEmpty()) {
	Bundle bundle = Platform.getBundle(extension.getContributor().getName());
	if (bundle != null) {
	try {
	return (Class<? extends LanguageServer>) bundle.loadClass(serverInterface);
	} catch (ClassNotFoundException exception) {
	StatusManager.getManager().handle(new Status(IStatus.ERROR, LanguageServerPlugin.PLUGIN_ID,
	exception.getMessage(), exception));
	}
	}
	}
	return super.getServerInterface();
	}

	@SuppressWarnings("unchecked")
	@Override
	public <S extends LanguageServer> Launcher.Builder<S> createLauncherBuilder() {
	String launcherSupplier = extension.getAttribute(LAUNCHER_BUILDER_ATTRIBUTE);
	if (launcherSupplier != null && !launcherSupplier.isEmpty()) {
	try {
	return (Launcher.Builder<S>) extension.createExecutableExtension(LAUNCHER_BUILDER_ATTRIBUTE);
	} catch (CoreException e) {
	StatusManager.getManager().handle(e, LanguageServerPlugin.PLUGIN_ID);
	}
	}
	return super.createLauncherBuilder();
	}

	}

	static class LaunchConfigurationLanguageServerDefinition extends LanguageServerDefinition {
	final ILaunchConfiguration launchConfiguration;
	final Set<String> launchModes;

	public LaunchConfigurationLanguageServerDefinition(ILaunchConfiguration launchConfiguration,
	Set<String> launchModes) {
	super(launchConfiguration.getName(), launchConfiguration.getName(), false);
	this.launchConfiguration = launchConfiguration;
	this.launchModes = launchModes;
	}

	@Override
	public StreamConnectionProvider createConnectionProvider() {
	return new LaunchConfigurationStreamProvider(this.launchConfiguration, launchModes);
	}
	}

	private static LanguageServersRegistry INSTANCE = null;
	public static LanguageServersRegistry getInstance() {
	if (INSTANCE == null) {
	INSTANCE = new LanguageServersRegistry();
	}
	return INSTANCE;
	}

	private List<ContentTypeToLanguageServerDefinition> connections = new ArrayList<>();
	private IPreferenceStore preferenceStore;

	private LanguageServersRegistry() {
	this.preferenceStore = LanguageServerPlugin.getDefault().getPreferenceStore();
	initialize();
	}

	private void initialize() {
	String prefs = preferenceStore.getString(CONTENT_TYPE_TO_LSP_LAUNCH_PREF_KEY);
	if (prefs != null && !prefs.isEmpty()) {
	String[] entries = prefs.split(","); //$NON-NLS-1$
	for (String entry : entries) {
	ContentTypeToLSPLaunchConfigEntry mapping = ContentTypeToLSPLaunchConfigEntry.readFromPreference(entry);
	if (mapping != null) {
	connections.add(mapping);
	}
	}
	}

	Map<String, LanguageServerDefinition> servers = new HashMap<>();
	List<ContentTypeMapping> contentTypes = new ArrayList<>();
	for (IConfigurationElement extension : Platform.getExtensionRegistry().getConfigurationElementsFor(EXTENSION_POINT_ID)) {
	String id = extension.getAttribute(ID_ATTRIBUTE);
	if (id != null && !id.isEmpty()) {
	if (extension.getName().equals(LS_ELEMENT)) {
	servers.put(id, new ExtensionLanguageServerDefinition(extension));
	} else if (extension.getName().equals(MAPPING_ELEMENT)) {
	IContentType contentType = Platform.getContentTypeManager().getContentType(extension.getAttribute(CONTENT_TYPE_ATTRIBUTE));
	String languageId = extension.getAttribute(LANGUAGE_ID_ATTRIBUTE);
	EnablementTester expression = null;
	if (extension.getChildren(ENABLED_WHEN_ATTRIBUTE) != null) {
	IConfigurationElement[] enabledWhenElements = extension.getChildren(ENABLED_WHEN_ATTRIBUTE);
	if (enabledWhenElements.length == 1) {
	IConfigurationElement enabledWhen = enabledWhenElements[0];
	IConfigurationElement[] enabledWhenChildren = enabledWhen.getChildren();
	if (enabledWhenChildren.length == 1) {
	try {
	String description = enabledWhen.getAttribute(ENABLED_WHEN_DESC);
	expression = new EnablementTester(this::evaluationContext,
	ExpressionConverter.getDefault().perform(enabledWhenChildren[0]),
	description);
	} catch (CoreException e) {
	LanguageServerPlugin.logWarning(e.getMessage(), e);
	}
	}
	}
	}
	if (contentType != null) {
	contentTypes.add(new ContentTypeMapping(contentType, id, languageId, expression));
	}
	}
	}
	}

	for (ContentTypeMapping mapping : contentTypes) {
	LanguageServerDefinition lsDefinition = servers.get(mapping.id);
	if (lsDefinition != null) {
	registerAssociation(mapping.contentType, lsDefinition, mapping.languageId, mapping.enablement);
	} else {
	LanguageServerPlugin.logWarning("server '" + mapping.id + "' not available", null); //$NON-NLS-1$ //$NON-NLS-2$
	}
	}
	}

	private IEvaluationContext evaluationContext() {
	return Optional.ofNullable(PlatformUI.getWorkbench().getService(IHandlerService.class))//
	.map(IHandlerService::getCurrentState)//
	.orElse(null);
	}

	private void persistContentTypeToLaunchConfigurationMapping() {
	StringBuilder builder = new StringBuilder();
	for (ContentTypeToLSPLaunchConfigEntry entry : getContentTypeToLSPLaunches()) {
	entry.appendPreferenceTo(builder);
	builder.append(',');
	}
	if (builder.length() > 0) {
	builder.deleteCharAt(builder.length() - 1);
	}
	this.preferenceStore.setValue(CONTENT_TYPE_TO_LSP_LAUNCH_PREF_KEY, builder.toString());
	if (this.preferenceStore instanceof IPersistentPreferenceStore) {
	try {
	((IPersistentPreferenceStore) this.preferenceStore).save();
	} catch (IOException e) {
	LanguageServerPlugin.logError(e);
	}
	}
	}

	/**
	* @param contentType
	* @return the {@link LanguageServerDefinition}s <strong>directly</strong> associated to the given content-type.
	* This does <strong>not</strong> include the one that match transitively as per content-type hierarchy
	*/
	List<ContentTypeToLanguageServerDefinition> findProviderFor(final @NonNull IContentType contentType) {
	return connections.stream()
	.filter(entry -> entry.getKey().equals(contentType))
	.sorted((mapping1, mapping2) -> {
	// this sort should make that the content-type hierarchy is respected
	// and the most specialized content-type are placed before the more generic ones
	if (mapping1.getKey().isKindOf(mapping2.getKey())) {
	return -1;
	} else if (mapping2.getKey().isKindOf(mapping1.getKey())) {
	return +1;
	}
	// TODO support "priority" attribute, but it's not made public
	return mapping1.getKey().getId().compareTo(mapping2.getKey().getId());
	})
	.collect(Collectors.toList());
	}

	public void registerAssociation(@NonNull IContentType contentType, @NonNull ILaunchConfiguration launchConfig, @NonNull Set<String> launchMode) {
	ContentTypeToLSPLaunchConfigEntry mapping = new ContentTypeToLSPLaunchConfigEntry(contentType, launchConfig,
	launchMode);
	connections.add(mapping);
	persistContentTypeToLaunchConfigurationMapping();
	}

	public void registerAssociation(@NonNull IContentType contentType,
	@NonNull LanguageServerDefinition serverDefinition, @Nullable String languageId,
	EnablementTester enablement) {
	if (languageId != null) {
	serverDefinition.registerAssociation(contentType, languageId);
	}

	connections.add(new ContentTypeToLanguageServerDefinition(contentType, serverDefinition, enablement));
	}

	public void setAssociations(List<ContentTypeToLSPLaunchConfigEntry> wc) {
	this.connections.removeIf(ContentTypeToLSPLaunchConfigEntry.class::isInstance);
	this.connections.addAll(wc);
	persistContentTypeToLaunchConfigurationMapping();
	}

	public List<ContentTypeToLSPLaunchConfigEntry> getContentTypeToLSPLaunches() {
	return this.connections.stream().filter(ContentTypeToLSPLaunchConfigEntry.class::isInstance).map(ContentTypeToLSPLaunchConfigEntry.class::cast).collect(Collectors.toList());
	}

	public List<ContentTypeToLanguageServerDefinition> getContentTypeToLSPExtensions() {
	return this.connections.stream().filter(mapping -> mapping.getValue() instanceof ExtensionLanguageServerDefinition).collect(Collectors.toList());
	}

	public @Nullable LanguageServerDefinition getDefinition(@NonNull String languageServerId) {
	for (ContentTypeToLanguageServerDefinition mapping : this.connections) {
	if (mapping.getValue().id.equals(languageServerId)) {
	return mapping.getValue();
	}
	}
	return null;
	}

	/**
	* internal class to capture content-type mappings for language servers
	*/
	private static class ContentTypeMapping {

	@NonNull public final String id;
	@NonNull public final IContentType contentType;
	@Nullable public final String languageId;
	@Nullable
	public final EnablementTester enablement;

	public ContentTypeMapping(@NonNull IContentType contentType, @NonNull String id, @Nullable String languageId,
	@Nullable EnablementTester enablement) {
	this.contentType = contentType;
	this.id = id;
	this.languageId = languageId;
	this.enablement = enablement;
	}

	}

	/**
	* @param file
	* @param serverDefinition
	* @return whether the given serverDefinition is suitable for the file
	*/
	public boolean matches(@NonNull IFile file, @NonNull LanguageServerDefinition serverDefinition) {
	return getAvailableLSFor(LSPEclipseUtils.getFileContentTypes(file)).contains(serverDefinition);
	}

	/**
	* @param document
	* @param serverDefinition
	* @return whether the given serverDefinition is suitable for the file
	*/
	public boolean matches(@NonNull IDocument document, @NonNull LanguageServerDefinition serverDefinition) {
	return getAvailableLSFor(LSPEclipseUtils.getDocumentContentTypes(document)).contains(serverDefinition);
	}

	public boolean canUseLanguageServer(@NonNull IEditorInput editorInput) {
	return !getAvailableLSFor(
	Arrays.asList(Platform.getContentTypeManager().findContentTypesFor(editorInput.getName()))).isEmpty();
	}

	public boolean canUseLanguageServer(@NonNull IDocument document) {
	List<IContentType> contentTypes = LSPEclipseUtils.getDocumentContentTypes(document);

	if (contentTypes.isEmpty()) {
	return false;
	}

	return !getAvailableLSFor(contentTypes).isEmpty();
	}

	public boolean canUseLanguageServer(@NonNull IFile file) {
	return !getAvailableLSFor(LSPEclipseUtils.getFileContentTypes(file)).isEmpty();
	}

	private Set<LanguageServerDefinition> getAvailableLSFor(Collection<IContentType> contentTypes) {
	Set<LanguageServerDefinition> res = new HashSet<>();
	for (ContentTypeToLanguageServerDefinition mapping : this.connections) {
	if (mapping.isEnabled() && contentTypes.contains(mapping.getKey())) {
	res.add(mapping.getValue());
	}
	}
	return res;
	}

	}