Removed ILanguageServer no longer used. (#19921)

I am removing ILanguageServer and all interfaces/types existed around it
since it seems it is no longer used.

...

it looks like ILanguageServer used to be used for old jupyter
(https://github.com/microsoft/vscode-python/blob/main/src/client/jupyter/jupyterIntegration.ts#L146)
but it no longer used by jupyter anymore
(https://github.com/microsoft/vscode-jupyter/blob/70dc27d55c95cb81bfd32a6505b7fb357bfe624e/src/platform/api/types.ts#L74).
this PR (microsoft/vscode-jupyter#10889) removed
it from jupyter since it is not used. but it is never removed from
python extension.
...

I am doing this as a part of on-going client move work since we do not
want to expose ILanguageServer to pass to jupyter extension unless it is
required.

Author: heejaechang

src/client/activation/jedi/languageServerProxy.ts

@@ -16,7 +16,7 @@ import { killPid } from '../../common/process/rawProcessApis';
 import { traceDecoratorError, traceDecoratorVerbose, traceError } from '../../logging';
 
 export class JediLanguageServerProxy implements ILanguageServerProxy {
-    public languageClient: LanguageClient | undefined;
+    private languageClient: LanguageClient | undefined;
 
     private readonly disposables: Disposable[] = [];
 

src/client/activation/jedi/manager.ts

@@ -59,10 +59,6 @@ export class JediLanguageServerManager implements ILanguageServerManager {
         this.disposables.forEach((d) => d.dispose());
     }
 
-    public get languageProxy(): ILanguageServerProxy | undefined {
-        return this.languageServerProxy;
-    }
-
     @traceDecoratorError('Failed to start language server')
     public async start(resource: Resource, interpreter: PythonEnvironment | undefined): Promise<void> {
         this.resource = resource;

src/client/activation/node/manager.ts

@@ -11,9 +11,10 @@ import { captureTelemetry } from '../../telemetry';
 import { EventName } from '../../telemetry/constants';
 import { Commands } from '../commands';
 import { NodeLanguageClientMiddleware } from './languageClientMiddleware';
-import { ILanguageServerAnalysisOptions, ILanguageServerManager, ILanguageServerProxy } from '../types';
+import { ILanguageServerAnalysisOptions, ILanguageServerManager } from '../types';
 import { traceDecoratorError, traceDecoratorVerbose } from '../../logging';
 import { PYLANCE_EXTENSION_ID } from '../../common/constants';
+import { NodeLanguageServerProxy } from './languageServerProxy';
 
 export class NodeLanguageServerManager implements ILanguageServerManager {
     private resource!: Resource;
@@ -35,7 +36,7 @@ export class NodeLanguageServerManager implements ILanguageServerManager {
     constructor(
         private readonly serviceContainer: IServiceContainer,
         private readonly analysisOptions: ILanguageServerAnalysisOptions,
-        private readonly languageServerProxy: ILanguageServerProxy,
+        private readonly languageServerProxy: NodeLanguageServerProxy,
         commandManager: ICommandManager,
         private readonly extensions: IExtensions,
     ) {
@@ -59,10 +60,6 @@ export class NodeLanguageServerManager implements ILanguageServerManager {
         this.disposables.forEach((d) => d.dispose());
     }
 
-    public get languageProxy(): ILanguageServerProxy {
-        return this.languageServerProxy;
-    }
-
     @traceDecoratorError('Failed to start language server')
     public async start(resource: Resource, interpreter: PythonEnvironment | undefined): Promise<void> {
         if (this.started) {

src/client/activation/serviceRegistry.ts

@@ -9,7 +9,6 @@ import {
     IExtensionActivationManager,
     IExtensionActivationService,
     IExtensionSingleActivationService,
-    ILanguageServerCache,
     ILanguageServerOutputChannel,
 } from './types';
 import { LoadLanguageServerExtension } from './common/loadLanguageServerExtension';
@@ -36,7 +35,6 @@ export function registerTypes(serviceManager: IServiceManager): void {
 
     serviceManager.addSingleton<ILanguageServerWatcher>(ILanguageServerWatcher, LanguageServerWatcher);
     serviceManager.addBinding(ILanguageServerWatcher, IExtensionActivationService);
-    serviceManager.addBinding(ILanguageServerWatcher, ILanguageServerCache);
     serviceManager.addSingleton<LspNotebooksExperiment>(LspNotebooksExperiment, LspNotebooksExperiment);
     serviceManager.addBinding(LspNotebooksExperiment, IExtensionSingleActivationService);
 }

src/client/activation/types.ts

@@ -3,19 +3,8 @@
 
 'use strict';
 
-import {
-    CodeLensProvider,
-    CompletionItemProvider,
-    DefinitionProvider,
-    DocumentSymbolProvider,
-    Event,
-    HoverProvider,
-    ReferenceProvider,
-    RenameProvider,
-    SignatureHelpProvider,
-} from 'vscode';
+import { Event } from 'vscode';
 import { LanguageClient, LanguageClientOptions } from 'vscode-languageclient/node';
-import * as lsp from 'vscode-languageserver-protocol';
 import type { IDisposable, IOutputChannel, Resource } from '../common/types';
 import { PythonEnvironment } from '../pythonEnvironments/info';
 
@@ -69,41 +58,13 @@ export enum LanguageServerType {
     None = 'None',
 }
 
-/**
- * This interface is a subset of the vscode-protocol connection interface.
- * It's the minimum set of functions needed in order to talk to a language server.
- */
-export type ILanguageServerConnection = Pick<
-    lsp.ProtocolConnection,
-    'sendRequest' | 'sendNotification' | 'onProgress' | 'sendProgress' | 'onNotification' | 'onRequest'
->;
-
-export interface ILanguageServer
-    extends RenameProvider,
-        DefinitionProvider,
-        HoverProvider,
-        ReferenceProvider,
-        CompletionItemProvider,
-        CodeLensProvider,
-        DocumentSymbolProvider,
-        SignatureHelpProvider,
-        IDisposable {
-    readonly connection?: ILanguageServerConnection;
-    readonly capabilities?: lsp.ServerCapabilities;
-}
-
 export const ILanguageServerActivator = Symbol('ILanguageServerActivator');
-export interface ILanguageServerActivator extends ILanguageServer {
+export interface ILanguageServerActivator {
     start(resource: Resource, interpreter: PythonEnvironment | undefined): Promise<void>;
     activate(): void;
     deactivate(): void;
 }
 
-export const ILanguageServerCache = Symbol('ILanguageServerCache');
-export interface ILanguageServerCache {
-    get(resource: Resource, interpreter?: PythonEnvironment): Promise<ILanguageServer>;
-}
-
 export const ILanguageClientFactory = Symbol('ILanguageClientFactory');
 export interface ILanguageClientFactory {
     createLanguageClient(
@@ -121,18 +82,13 @@ export interface ILanguageServerAnalysisOptions extends IDisposable {
 }
 export const ILanguageServerManager = Symbol('ILanguageServerManager');
 export interface ILanguageServerManager extends IDisposable {
-    readonly languageProxy: ILanguageServerProxy | undefined;
     start(resource: Resource, interpreter: PythonEnvironment | undefined): Promise<void>;
     connect(): void;
     disconnect(): void;
 }
 
 export const ILanguageServerProxy = Symbol('ILanguageServerProxy');
 export interface ILanguageServerProxy extends IDisposable {
-    /**
-     * LanguageClient in use
-     */
-    languageClient: LanguageClient | undefined;
     start(
         resource: Resource,
         interpreter: PythonEnvironment | undefined,

src/client/jupyter/jupyterIntegration.ts

@@ -6,10 +6,8 @@
 
 import { inject, injectable, named } from 'inversify';
 import { dirname } from 'path';
-import { CancellationToken, Disposable, Event, Extension, Memento, Uri } from 'vscode';
-import * as lsp from 'vscode-languageserver-protocol';
+import { CancellationToken, Event, Extension, Memento, Uri } from 'vscode';
 import type { SemVer } from 'semver';
-import { ILanguageServerCache, ILanguageServerConnection } from '../activation/types';
 import { IWorkspaceService } from '../common/application/types';
 import { JUPYTER_EXTENSION_ID } from '../common/constants';
 import { InterpreterUri, ModuleInstallFlags } from '../common/installer/types';
@@ -23,7 +21,6 @@ import {
     ProductInstallStatus,
     Resource,
 } from '../common/types';
-import { isResource } from '../common/utils/misc';
 import { getDebugpyPackagePath } from '../debugger/extension/adapter/remoteLaunchers';
 import { IEnvironmentActivationService } from '../interpreter/activation/types';
 import { IInterpreterQuickPickItem, IInterpreterSelector } from '../interpreter/configuration/types';
@@ -38,11 +35,6 @@ import {
 import { PythonEnvironment } from '../pythonEnvironments/info';
 import { IDataViewerDataProvider, IJupyterUriProvider } from './types';
 
-interface ILanguageServer extends Disposable {
-    readonly connection: ILanguageServerConnection;
-    readonly capabilities: lsp.ServerCapabilities;
-}
-
 /**
  * This allows Python extension to update Product enum without breaking Jupyter.
  * I.e. we have a strict contract, else using numbers (in enums) is bound to break across products.
@@ -139,11 +131,6 @@ type PythonApiForJupyterExtension = {
      * Retrieve interpreter path selected for Jupyter server from Python memento storage
      */
     getInterpreterPathSelectedForJupyterServer(): string | undefined;
-    /**
-     * Returns a ILanguageServer that can be used for communicating with a language server process.
-     * @param resource file that determines which connection to return
-     */
-    getLanguageServer(resource?: InterpreterUri): Promise<ILanguageServer | undefined>;
     /**
      * Registers a visibility filter for the interpreter status bar.
      */
@@ -207,7 +194,6 @@ export class JupyterExtensionIntegration {
         @inject(IInterpreterSelector) private readonly interpreterSelector: IInterpreterSelector,
         @inject(IInstaller) private readonly installer: IInstaller,
         @inject(IEnvironmentActivationService) private readonly envActivation: IEnvironmentActivationService,
-        @inject(ILanguageServerCache) private readonly languageServerCache: ILanguageServerCache,
         @inject(IMemento) @named(GLOBAL_MEMENTO) private globalState: Memento,
         @inject(IInterpreterDisplay) private interpreterDisplay: IInterpreterDisplay,
         @inject(IComponentAdapter) private pyenvs: IComponentAdapter,
@@ -272,21 +258,6 @@ export class JupyterExtensionIntegration {
             getDebuggerPath: async () => dirname(getDebugpyPackagePath()),
             getInterpreterPathSelectedForJupyterServer: () =>
                 this.globalState.get<string | undefined>('INTERPRETER_PATH_SELECTED_FOR_JUPYTER_SERVER'),
-            getLanguageServer: async (r) => {
-                const resource = isResource(r) ? r : undefined;
-                const interpreter = !isResource(r) ? r : undefined;
-                const client = await this.languageServerCache.get(resource, interpreter);
-
-                // Some language servers don't support the connection yet.
-                if (client && client.connection && client.capabilities) {
-                    return {
-                        connection: client.connection,
-                        capabilities: client.capabilities,
-                        dispose: client.dispose,
-                    };
-                }
-                return undefined;
-            },
             registerInterpreterStatusFilter: this.interpreterDisplay.registerVisibilityFilter.bind(
                 this.interpreterDisplay,
             ),

src/client/languageServer/jediLSExtensionManager.ts

@@ -19,14 +19,12 @@ import { IInterpreterService } from '../interpreter/contracts';
 import { IServiceContainer } from '../ioc/types';
 import { traceError } from '../logging';
 import { PythonEnvironment } from '../pythonEnvironments/info';
-import { LanguageServerCapabilities } from './languageServerCapabilities';
 import { ILanguageServerExtensionManager } from './types';
 
-export class JediLSExtensionManager extends LanguageServerCapabilities
-    implements IDisposable, ILanguageServerExtensionManager {
-    serverManager: JediLanguageServerManager;
+export class JediLSExtensionManager implements IDisposable, ILanguageServerExtensionManager {
+    private serverProxy: JediLanguageServerProxy;
 
-    serverProxy: JediLanguageServerProxy;
+    serverManager: JediLanguageServerManager;
 
     clientFactory: JediLanguageClientFactory;
 
@@ -43,8 +41,6 @@ export class JediLSExtensionManager extends LanguageServerCapabilities
         environmentService: IEnvironmentVariablesProvider,
         commandManager: ICommandManager,
     ) {
-        super();
-
         this.analysisOptions = new JediLanguageServerAnalysisOptions(
             environmentService,
             outputChannel,