@@ -6,6 +6,7 @@
 
 import * as assert from 'assert';
 import * as path from 'path';
+import * as sinon from 'sinon';
 import * as vscode from 'vscode';
 import * as lsclient from 'vscode-languageclient/node';
 import * as proto from 'vscode-languageserver-protocol';
@@ -240,6 +241,57 @@ suite('Server output', () => {
 		assert.strictEqual(stderrCalled, true);
 		await client.stop();
 	});
+
+	test('JSON-RPC diagnostics are routed to the output channel', async () => {
+		const serverModule = path.join(__dirname, './servers/customServer.js');
+		const serverOptions: lsclient.ServerOptions = {
+			module: serverModule,
+			transport: lsclient.TransportKind.ipc,
+		};
+		const client = new lsclient.LanguageClient('test diagnostics', 'Test Diagnostics Language Server', serverOptions, {});
+		assert.strictEqual((client as any)._outputChannel, undefined, 'no output channel should exist before the client is used');
+
+		const errorLog = sinon.spy(client, 'error');
+		await client.start();
+
+		// A throwing notification handler makes the jsonrpc connection catch the
+		// error and log a diagnostic through the shared logger.
+		client.onNotification('notification', () => {
+			throw new Error('boom');
+		});
+		await client.sendRequest('triggerNotification');
+
+		// The diagnostic must go through the client's guarded error() method (which
+		// respects shouldLogToOutputChannel()) rather than straight to the output
+		// channel or console, so a diagnostic that arrives after shutdown can't
+		// recreate a disposed channel.
+		assert.ok(errorLog.calledOnce, 'expected exactly one diagnostic to be logged');
+		assert.ok(/boom/.test(errorLog.firstCall.args[0]), 'expected the handler failure diagnostic');
+		assert.strictEqual(errorLog.firstCall.args[2], false, 'protocol diagnostics must not force a notification popup');
+
+		await client.stop();
+	});
+
+	test('JSON-RPC diagnostics after stop() do not recreate the output channel', async () => {
+		const serverModule = path.join(__dirname, './servers/customServer.js');
+		const serverOptions: lsclient.ServerOptions = {
+			module: serverModule,
+			transport: lsclient.TransportKind.ipc,
+		};
+		const client = new lsclient.LanguageClient('test diagnostics after stop', 'Test Diagnostics After Stop Language Server', serverOptions, {});
+		await client.start();
+		// client.start() already creates the output channel as a side effect of
+		// wiring up the trace log level listener, independent of any diagnostic.
+		assert.notStrictEqual((client as any)._outputChannel, undefined);
+		await client.stop();
+		assert.strictEqual((client as any)._outputChannel, undefined, 'stop() must dispose and clear the output channel');
+
+		// Simulate a diagnostic that is logged after the client considers itself
+		// stopped. shouldLogToOutputChannel() must suppress it so a disposed
+		// channel is not recreated for a client that is no longer running.
+		client.error('late diagnostic', undefined, false);
+		assert.strictEqual((client as any)._outputChannel, undefined, 'a diagnostic logged after stop() must not recreate the output channel');
+	});
 });
 
 suite('Socket transport', () => {
 
@@ -1836,7 +1836,7 @@ export abstract class BaseLanguageClient implements FeatureClient<Middleware, La
 		};
 
 		const transports = await this.createMessageTransports(this._clientOptions.stdioEncoding || 'utf8');
-		this._connection = createConnection(transports.reader, transports.writer, errorHandler, closeHandler, this._clientOptions.connectionOptions);
+		this._connection = createConnection(transports.reader, transports.writer, errorHandler, closeHandler, this, this._clientOptions.connectionOptions);
 		return this._connection;
 	}
 
@@ -2480,6 +2480,29 @@ class ConsoleLogger implements Logger {
 	}
 }
 
+interface ChannelProvider {
+	error(message: string, data?: any, showNotification?: boolean | 'force'): void;
+	warn(message: string, data?: any, showNotification?: boolean): void;
+	info(message: string, data?: any, showNotification?: boolean): void;
+}
+
+class OutputChannelLogger implements Logger {
+	constructor(private readonly channelProvider: ChannelProvider) {
+	}
+	public error(message: string): void {
+		this.channelProvider.error(message, undefined, false);
+	}
+	public warn(message: string): void {
+		this.channelProvider.warn(message, undefined, false);
+	}
+	public info(message: string): void {
+		this.channelProvider.info(message, undefined, false);
+	}
+	public log(message: string): void {
+		this.channelProvider.info(message, undefined, false);
+	}
+}
+
 interface ConnectionErrorHandler {
 	(error: Error, message: Message | undefined, count: number | undefined): void;
 }
@@ -2488,8 +2511,8 @@ interface ConnectionCloseHandler {
 	(): void;
 }
 
-function createConnection(input: MessageReader, output: MessageWriter, errorHandler: ConnectionErrorHandler, closeHandler: ConnectionCloseHandler, options?: ConnectionOptions): Connection {
-	const logger = new ConsoleLogger();
+function createConnection(input: MessageReader, output: MessageWriter, errorHandler: ConnectionErrorHandler, closeHandler: ConnectionCloseHandler, channelProvider: ChannelProvider | undefined, options?: ConnectionOptions): Connection {
+	const logger: Logger = channelProvider !== undefined ? new OutputChannelLogger(channelProvider) : new ConsoleLogger();
 	const connection = createProtocolConnection(input, output, logger, options);
 	connection.onError((data) => { errorHandler(data[0], data[1], data[2]); });
 	connection.onClose(closeHandler);