From 9542c9f43312bfdb20fc5f4a14eeec3525643f8e Mon Sep 17 00:00:00 2001
From: Johannes Rieken <johannes.rieken@gmail.com>
Date: Mon, 19 Jun 2017 12:01:58 +0200
Subject: [PATCH] add setEagerModelSync-function to defaults, fixes  #461

---
 src/monaco.contribution.ts | 11 +++++++++++
 src/monaco.d.ts            |  6 ++++++
 src/workerManager.ts       | 27 +++++++++++++++++++--------
 3 files changed, 36 insertions(+), 8 deletions(-)

diff --git a/src/monaco.contribution.ts b/src/monaco.contribution.ts
index ef4a915a..fce13497 100644
--- a/src/monaco.contribution.ts
+++ b/src/monaco.contribution.ts
@@ -19,6 +19,7 @@ export class LanguageServiceDefaultsImpl implements monaco.languages.typescript.
 	private _onDidChange = new Emitter<monaco.languages.typescript.LanguageServiceDefaults>();
 	private _extraLibs: { [path: string]: string };
 	private _workerMaxIdleTime: number;
+	private _eagerModelSync: boolean;
 	private _compilerOptions: monaco.languages.typescript.CompilerOptions;
 	private _diagnosticsOptions: monaco.languages.typescript.DiagnosticsOptions;
 
@@ -89,6 +90,16 @@ export class LanguageServiceDefaultsImpl implements monaco.languages.typescript.
 	getWorkerMaxIdleTime() {
 		return this._workerMaxIdleTime;
 	}
+
+	setEagerModelSync(value: boolean) {
+		// doesn't fire an event since no
+		// worker restart is required here
+		this._eagerModelSync = value;
+	}
+
+	getEagerModelSync() {
+		return this._eagerModelSync;
+	}
 }
 
 // --- BEGIN enums copied from typescript to prevent loading the entire typescriptServices ---
diff --git a/src/monaco.d.ts b/src/monaco.d.ts
index 4859df4e..ce026e1b 100644
--- a/src/monaco.d.ts
+++ b/src/monaco.d.ts
@@ -136,6 +136,12 @@ declare module monaco.languages.typescript {
          * mean never shut down.
          */
         setMaximunWorkerIdleTime(value: number): void;
+
+        /**
+         * Configure if all existing models should be eagerly sync'd
+         * to the worker on start or restart.
+         */
+        setEagerModelSync(value: boolean): void;
     }
 
     export var typescriptDefaults: LanguageServiceDefaults;
diff --git a/src/workerManager.ts b/src/workerManager.ts
index adf63226..3fe0606e 100644
--- a/src/workerManager.ts
+++ b/src/workerManager.ts
@@ -4,8 +4,8 @@
  *--------------------------------------------------------------------------------------------*/
 'use strict';
 
-import {LanguageServiceDefaultsImpl} from './monaco.contribution';
-import {TypeScriptWorker} from './worker';
+import { LanguageServiceDefaultsImpl } from './monaco.contribution';
+import { TypeScriptWorker } from './worker';
 
 import Promise = monaco.Promise;
 import IDisposable = monaco.IDisposable;
@@ -22,7 +22,7 @@ export class WorkerManager {
 	private _worker: monaco.editor.MonacoWebWorker<TypeScriptWorker>;
 	private _client: Promise<TypeScriptWorker>;
 
-	constructor(modeId:string, defaults: LanguageServiceDefaultsImpl) {
+	constructor(modeId: string, defaults: LanguageServiceDefaultsImpl) {
 		this._modeId = modeId;
 		this._defaults = defaults;
 		this._worker = null;
@@ -74,14 +74,25 @@ export class WorkerManager {
 				}
 			});
 
-			this._client = this._worker.getProxy();
+			let p = this._worker.getProxy();
+
+			if (this._defaults.getEagerModelSync()) {
+				p = p.then(worker => {
+					return this._worker.withSyncedResources(monaco.editor.getModels()
+						.filter(model => model.getModeId() === this._modeId)
+						.map(model => model.uri)
+					);
+				})
+			}
+
+			this._client = p;
 		}
 
 		return this._client;
 	}
 
 	getLanguageServiceWorker(...resources: Uri[]): Promise<TypeScriptWorker> {
-		let _client:TypeScriptWorker;
+		let _client: TypeScriptWorker;
 		return toShallowCancelPromise(
 			this._getClient().then((client) => {
 				_client = client
@@ -92,9 +103,9 @@ export class WorkerManager {
 	}
 }
 
-function toShallowCancelPromise<T>(p:Promise<T>): Promise<T> {
-	let completeCallback: (value:T)=>void;
-	let errorCallback: (err:any)=>void;
+function toShallowCancelPromise<T>(p: Promise<T>): Promise<T> {
+	let completeCallback: (value: T) => void;
+	let errorCallback: (err: any) => void;
 
 	let r = new Promise<T>((c, e) => {
 		completeCallback = c;