Enable web TS Server

extensions/typescript-language-features/extension-browser.webpack.config.js

@@ -6,13 +6,21 @@
 //@ts-check
 
 'use strict';
+const CopyPlugin = require('copy-webpack-plugin');
 
 const withBrowserDefaults = require('../shared.webpack.config').browser;
 
 module.exports = withBrowserDefaults({
 	context: __dirname,
 	entry: {
 		extension: './src/extension.browser.ts',
-		'tsserver.browser': './src/tsserver.browser.ts',
-	}
+	},
+	plugins: [
+		// @ts-ignore
+		new CopyPlugin({
+			patterns: [
+				{ from: 'node_modules/typescript-web-server', to: 'typescript-web' }
+			],
+		}),
+	],
 });

extensions/typescript-language-features/package.json

@@ -27,10 +27,14 @@
     "@types/node": "^12.11.7",
     "@types/rimraf": "2.0.2",
     "@types/semver": "^5.5.0",
+    "copy-webpack-plugin": "^6.0.3",
+    "typescript-web-server": "git://github.com/mjbvz/ts-server-web-build",
     "vscode": "^1.1.36"
   },
   "scripts": {
-    "vscode:prepublish": "node ../../node_modules/gulp/bin/gulp.js --gulpfile ../../build/gulpfile.extensions.js compile-extension:typescript-language-features"
+    "vscode:prepublish": "node ../../node_modules/gulp/bin/gulp.js --gulpfile ../../build/gulpfile.extensions.js compile-extension:typescript-language-features",
+    "compile-web": "npx webpack-cli --config extension-browser.webpack.config --mode none",
+    "watch-web": "npx webpack-cli --config extension-browser.webpack.config --mode none --watch --info-verbosity verbose"
   },
   "activationEvents": [
     "onLanguage:javascript",
@@ -50,6 +54,7 @@
     "onLanguage:jsonc"
   ],
   "main": "./out/extension",
+  "browser": "./dist/browser/extension",
   "contributes": {
     "jsonValidation": [
       {

extensions/typescript-language-features/src/extension.browser.ts

@@ -4,14 +4,36 @@
  *--------------------------------------------------------------------------------------------*/
 
 import * as vscode from 'vscode';
-import { noopLogDirectoryProvider } from './tsServer/logDirectoryProvider';
+import { WorkerServerProcess } from './tsServer/workerServerProcess';
 import { Api, getExtensionApi } from './api';
 import { registerCommands } from './commands/index';
 import { LanguageConfigurationManager } from './features/languageConfiguration';
 import { createLazyClientHost, lazilyActivateClient } from './lazyClientHost';
+import { noopRequestCancellerFactory } from './tsServer/cancellation';
+import { noopLogDirectoryProvider } from './tsServer/logDirectoryProvider';
+import API from './utils/api';
 import { CommandManager } from './utils/commandManager';
+import { TypeScriptServiceConfiguration } from './utils/configuration';
 import { PluginManager } from './utils/plugins';
-import { noopRequestCancellerFactory } from './tsServer/cancellation';
+import { ITypeScriptVersionProvider, TypeScriptVersion, TypeScriptVersionSource } from './utils/versionProvider';
+
+class StaticVersionProvider implements ITypeScriptVersionProvider {
+
+	constructor(
+		private readonly _version: TypeScriptVersion
+	) { }
+
+	updateConfiguration(_configuration: TypeScriptServiceConfiguration): void {
+		// noop
+	}
+
+	get defaultVersion() { return this._version; }
+	get bundledVersion() { return this._version; }
+
+	readonly globalVersion = undefined;
+	readonly localVersion = undefined;
+	readonly localVersions = [];
+}
 
 export function activate(
 	context: vscode.ExtensionContext
@@ -25,7 +47,13 @@ export function activate(
 	const onCompletionAccepted = new vscode.EventEmitter<vscode.CompletionItem>();
 	context.subscriptions.push(onCompletionAccepted);
 
-	const lazyClientHost = createLazyClientHost(context, pluginManager, commandManager, noopLogDirectoryProvider, noopRequestCancellerFactory, item => {
+	const versionProvider = new StaticVersionProvider(
+		new TypeScriptVersion(
+			TypeScriptVersionSource.Bundled,
+			'/builtin-extension/typescript-language-features/dist/browser/typescript-web/tsserver.js',
+			API.v400));
+
+	const lazyClientHost = createLazyClientHost(context, false, pluginManager, commandManager, noopLogDirectoryProvider, noopRequestCancellerFactory, versionProvider, WorkerServerProcess, item => {
 		onCompletionAccepted.fire(item);
 	});
 

extensions/typescript-language-features/src/extension.ts

@@ -5,16 +5,19 @@
 
 import * as rimraf from 'rimraf';
 import * as vscode from 'vscode';
-import { NodeLogDirectoryProvider } from './tsServer/logDirectoryProvider.electron';
 import { Api, getExtensionApi } from './api';
 import { registerCommands } from './commands/index';
 import { LanguageConfigurationManager } from './features/languageConfiguration';
 import * as task from './features/task';
 import { createLazyClientHost, lazilyActivateClient } from './lazyClientHost';
 import { nodeRequestCancellerFactory } from './tsServer/cancellation.electron';
+import { NodeLogDirectoryProvider } from './tsServer/logDirectoryProvider.electron';
 import { CommandManager } from './utils/commandManager';
 import * as electron from './utils/electron';
+import { onCaseInsenitiveFileSystem } from './utils/fileSystem';
 import { PluginManager } from './utils/plugins';
+import { ChildServerProcess } from './utils/serverProcess';
+import { DiskTypeScriptVersionProvider } from './utils/versionProvider.electron';
 
 export function activate(
 	context: vscode.ExtensionContext
@@ -30,7 +33,9 @@ export function activate(
 
 	const logDirectoryProvider = new NodeLogDirectoryProvider(context);
 
-	const lazyClientHost = createLazyClientHost(context, pluginManager, commandManager, logDirectoryProvider, nodeRequestCancellerFactory, item => {
+	const versionProvider = new DiskTypeScriptVersionProvider();
+
+	const lazyClientHost = createLazyClientHost(context, onCaseInsenitiveFileSystem(), pluginManager, commandManager, logDirectoryProvider, nodeRequestCancellerFactory, versionProvider, ChildServerProcess, item => {
 		onCompletionAccepted.fire(item);
 	});
 

extensions/typescript-language-features/src/features/callHierarchy.ts

@@ -123,9 +123,9 @@ export function register(
 ) {
 	return conditionalRegistration([
 		requireMinVersion(client, TypeScriptCallHierarchySupport.minVersion),
-		requireSomeCapability(client, ClientCapability.EnhancedSyntax, ClientCapability.Semantic),
+		requireSomeCapability(client, ClientCapability.Semantic),
 	], () => {
-		return vscode.languages.registerCallHierarchyProvider(selector.syntax,
+		return vscode.languages.registerCallHierarchyProvider(selector.semantic,
 			new TypeScriptCallHierarchySupport(client));
 	});
 }

extensions/typescript-language-features/src/features/fileConfigurationManager.ts

@@ -9,7 +9,6 @@ import { ITypeScriptServiceClient } from '../typescriptService';
 import API from '../utils/api';
 import { Disposable } from '../utils/dispose';
 import * as fileSchemes from '../utils/fileSchemes';
-import { onCaseInsenitiveFileSystem } from '../utils/fileSystem';
 import { isTypeScriptDocument } from '../utils/languageModeIds';
 import { equals } from '../utils/objects';
 import { ResourceMap } from '../utils/resourceMap';
@@ -34,10 +33,11 @@ export default class FileConfigurationManager extends Disposable {
 	private readonly formatOptions: ResourceMap<Promise<FileConfiguration | undefined>>;
 
 	public constructor(
-		private readonly client: ITypeScriptServiceClient
+		private readonly client: ITypeScriptServiceClient,
+		onCaseInsenitiveFileSystem: boolean
 	) {
 		super();
-		this.formatOptions = new ResourceMap(undefined, { onCaseInsenitiveFileSystem: onCaseInsenitiveFileSystem() });
+		this.formatOptions = new ResourceMap(undefined, { onCaseInsenitiveFileSystem });
 		vscode.workspace.onDidCloseTextDocument(textDocument => {
 			// When a document gets closed delete the cached formatting options.
 			// This is necessary since the tsserver now closed a project when its

extensions/typescript-language-features/src/features/organizeImports.ts

@@ -6,11 +6,11 @@
 import * as vscode from 'vscode';
 import * as nls from 'vscode-nls';
 import type * as Proto from '../protocol';
-import { ITypeScriptServiceClient } from '../typescriptService';
+import { ClientCapability, ITypeScriptServiceClient } from '../typescriptService';
 import API from '../utils/api';
 import { nulToken } from '../utils/cancellation';
 import { Command, CommandManager } from '../utils/commandManager';
-import { conditionalRegistration, requireMinVersion } from '../utils/dependentRegistration';
+import { conditionalRegistration, requireMinVersion, requireSomeCapability } from '../utils/dependentRegistration';
 import { DocumentSelector } from '../utils/documentSelector';
 import { TelemetryReporter } from '../utils/telemetry';
 import * as typeconverts from '../utils/typeConverters';
@@ -108,10 +108,10 @@ export function register(
 ) {
 	return conditionalRegistration([
 		requireMinVersion(client, OrganizeImportsCodeActionProvider.minVersion),
-
+		requireSomeCapability(client, ClientCapability.Semantic),
 	], () => {
 		const organizeImportsProvider = new OrganizeImportsCodeActionProvider(client, commandManager, fileConfigurationManager, telemetryReporter);
-		return vscode.languages.registerCodeActionsProvider(selector.syntax,
+		return vscode.languages.registerCodeActionsProvider(selector.semantic,
 			organizeImportsProvider,
 			organizeImportsProvider.metadata);
 	});

extensions/typescript-language-features/src/lazyClientHost.ts

@@ -4,6 +4,7 @@
  *--------------------------------------------------------------------------------------------*/
 
 import * as vscode from 'vscode';
+import { TsServerProcessFactory } from './tsServer/server';
 import { OngoingRequestCancellerFactory } from './tsServer/cancellation';
 import { ILogDirectoryProvider } from './tsServer/logDirectoryProvider';
 import TypeScriptServiceClientHost from './typeScriptServiceClientHost';
@@ -14,23 +15,30 @@ import * as ProjectStatus from './utils/largeProjectStatus';
 import { lazy, Lazy } from './utils/lazy';
 import ManagedFileContextManager from './utils/managedFileContext';
 import { PluginManager } from './utils/plugins';
+import { ITypeScriptVersionProvider } from './utils/versionProvider';
 
 export function createLazyClientHost(
 	context: vscode.ExtensionContext,
+	onCaseInsenitiveFileSystem: boolean,
 	pluginManager: PluginManager,
 	commandManager: CommandManager,
 	logDirectoryProvider: ILogDirectoryProvider,
 	cancellerFactory: OngoingRequestCancellerFactory,
+	versionProvider: ITypeScriptVersionProvider,
+	processFactory: TsServerProcessFactory,
 	onCompletionAccepted: (item: vscode.CompletionItem) => void,
 ): Lazy<TypeScriptServiceClientHost> {
 	return lazy(() => {
 		const clientHost = new TypeScriptServiceClientHost(
 			standardLanguageDescriptions,
 			context.workspaceState,
+			onCaseInsenitiveFileSystem,
 			pluginManager,
 			commandManager,
 			logDirectoryProvider,
 			cancellerFactory,
+			versionProvider,
+			processFactory,
 			onCompletionAccepted);
 
 		context.subscriptions.push(clientHost);
@@ -46,7 +54,6 @@ export function createLazyClientHost(
 	});
 }
 
-
 export function lazilyActivateClient(
 	lazyClientHost: Lazy<TypeScriptServiceClientHost>,
 	pluginManager: PluginManager,

extensions/typescript-language-features/src/tsServer/server.ts

@@ -7,14 +7,16 @@ import * as vscode from 'vscode';
 import type * as Proto from '../protocol';
 import { EventName } from '../protocol.const';
 import { CallbackMap } from '../tsServer/callbackMap';
-import { OngoingRequestCanceller } from './cancellation';
 import { RequestItem, RequestQueue, RequestQueueingType } from '../tsServer/requestQueue';
 import { TypeScriptServerError } from '../tsServer/serverError';
 import { ServerResponse, TypeScriptRequests } from '../typescriptService';
+import { TypeScriptServiceConfiguration } from '../utils/configuration';
 import { Disposable } from '../utils/dispose';
 import { TelemetryReporter } from '../utils/telemetry';
 import Tracer from '../utils/tracer';
+import { TypeScriptVersionManager } from '../utils/versionManager';
 import { TypeScriptVersion } from '../utils/versionProvider';
+import { OngoingRequestCanceller } from './cancellation';
 
 export enum ExectuionTarget {
 	Semantic,
@@ -41,6 +43,23 @@ export interface TsServerDelegate {
 	onFatalError(command: string, error: Error): void;
 }
 
+export const enum TsServerProcessKind {
+	Main = 'main',
+	Syntax = 'syntax',
+	Semantic = 'semantic',
+	Diagnostics = 'diagnostics'
+}
+
+export interface TsServerProcessFactory {
+	fork(
+		tsServerPath: string,
+		args: readonly string[],
+		kind: TsServerProcessKind,
+		configuration: TypeScriptServiceConfiguration,
+		versionManager: TypeScriptVersionManager,
+	): TsServerProcess;
+}
+
 export interface TsServerProcess {
 	write(serverRequest: Proto.Request): void;
 
@@ -51,7 +70,6 @@ export interface TsServerProcess {
 	kill(): void;
 }
 
-
 export class ProcessBasedTsServer extends Disposable implements ITypeScriptServer {
 	private readonly _requestQueue = new RequestQueue();
 	private readonly _callbacks = new CallbackMap<Proto.Response>();