Monaco Loads In memory model even with Real file system

[vivekburman]

Hi, I've implemented my own LocalFileSystemProvider to use a real filesystem provider to work with real files in disk. Below wrapperConfig I'm not setting the codeResources under editorAppConfig since I want to post init() later in UI to load a specific file.

Now when I call init() it starts with a inmemory model and after calling await vscode.workspace.openTextDocument(uri);. And then start(). It continues to work with inmemory model only all changes are passed to LSP for the inmemory model and not the URI file I loaded with openTextDocument.

So my query is shouldn't it load the contents from openTextDocument onto the editor model and further changes be tracked on it?

WrapperConfig:

{
		id: `${props.workspacePID}`,
		$type: 'classic',
		vscodeApiConfig: {
			workspaceConfig: {
				enableWorkspaceTrust: true,
				workspaceProvider: {
                    trusted: true,
                    async open() {
                        window.open(window.location.href);
                        return true;
                    },
                    workspace: {
                        workspaceUri: props.workspaceUri
                    },
                },
			},
            serviceOverrides: {
                ...getKeybindingsServiceOverride(),
				...getTextMateServiceOverride(),
				...getThemeServiceOverride(),
				...getLanguagesServiceOverride(),
				...getConfigurationServiceOverride(),
            },
			userConfiguration: {
                json: JSON.stringify({
                    'workbench.colorTheme': 'Default Light Modern',
                    'editor.wordBasedSuggestions': 'off',
                    'editor.guides.bracketPairsHorizontal': true,
                    'editor.experimental.asyncTokenization': false
                })
            },
		},
		editorAppConfig: {
			languageDef: {
				languageExtensionConfig: {
					id: 'go',
					extensions: ['.go'],
					aliases: ['Go', 'go']
				}
			},
			monacoWorkerFactory: (logger) => {
				workerFactory({
					workerOverrides: {
						ignoreMapping: true,
						workerLoaders: {
							// languageDetectionWorkerService: () => new Worker(new URL('@codingame/monaco-vscode-language-detection-worker-service-override/worker', import.meta.url), { type: 'module' }),
							TextMateWorker: () => new Worker(new URL('@codingame/monaco-vscode-textmate-service-override/worker', import.meta.url), { type: 'module' }),
							TextEditorWorker: () => new Worker(new URL('monaco-editor/esm/vs/editor/editor.worker.js', import.meta.url), { type: 'module' })
						}
					},
					logger
				});
			},
			editorOptions: {
				language: "go",
			},
		},
		languageClientConfigs: {
			"go": {
				name: 'w-' + props.workspacePID,
				connection: {
					options: {
						$type: 'WebSocketUrl',
						url: `ws://${config.HOST}:${config.PORT}/codebase/ws`
					},
				},
				clientOptions: {
					documentSelector: ["go"],
					workspaceFolder: {
						index: 0,
					    name: "w-" + props.workspacePID,
					    uri: props.workspaceUri
					},
				},
			}
		}
	}

import {Disposable, DisposableStore} from 'vscode/vscode/vs/base/common/lifecycle';
import {Event, Emitter} from 'vscode/vscode/vs/base/common/event';
import {newWriteableStream} from 'vscode/vscode/vs/base/common/stream';
import {VSBuffer} from 'vscode/vscode/vs/base/common/buffer';
import {
	FileSystemProviderErrorCode,
	FileSystemProviderError,
	FileType,
	FilePermission,
} from 'vscode/vscode/vs/platform/files/common/files';
import FileIOService from 'api/fileioService';
import { extractErrorMsg } from 'util/helper';
import { registerCustomProvider } from '@codingame/monaco-vscode-files-service-override';

function createFileSystemProviderError(error, code) {
    return FileSystemProviderError.create(error, code);
}
class RegisterFile {
	constructor(uri, readonly=false) {
        this.uri = uri;
        this.readonly = readonly;
        this.type = FileType.File;
        this._onDidChange = new Emitter();
        this.onDidChange = this._onDidChange.event;
        this._onDidDelete = new Emitter();
        this.onDidDelete = this._onDidDelete.event;
        this.ctime = Date.now();
        this.mtime = Date.now();
		this.size = 0;
        // this.onDidChange(() => {
        //     this.mtime = Date.now();
        // });
    }
    async stats() {
        return {
            ctime: this.ctime,
            mtime: this.mtime,
            size: await this.getSize(),
            type: FileType.File,
            permissions: this.readonly ? FilePermission.Readonly : undefined
        };
    }
    async delete() {
        if (this.readonly) {
            throw createFileSystemProviderError('Not allowed', FileSystemProviderErrorCode.FileWriteLocked);
        }
        this._onDidDelete.fire();
    }
	async getSize() {
		try {
			const resposne = await FileIOService.getSize(this.uri.toString());
			return parseInt(resposne.headers['content-length'] || '0', 10);
		}catch(e){
			return 0;
		}
	}
}
class LocalFileSystemProvider extends Disposable {
	constructor() {
		super();
		this._onDidChangeFile = new Emitter();
		this.onDidChangeFile = this._onDidChangeFile.event;
		this.capabilities = 2 | 1024 | 16; //fileReadwrite | pathcasesensitive
		this.onDidChangeCapabilities = Event.None;
		this._registeredFiles = new Map();
		this._fileDescriptors = new Map();
		this._fdCounter = 0;
	}
	async registerFile(uri, options={readonly: false}) {
		const file = new RegisterFile(uri, options.readonly);
		const disposableStore = new DisposableStore();
		disposableStore.add(file.onDidDelete(() => {
			this._registeredFiles.delete(uri.toString());
			this._onDidChangeFile.fire([{
				type: 2, // deleted
				resource: uri
			}]);
		}));
		disposableStore.add(file.onDidChange(() => {
			this._onDidChangeFile.fire([{
				type: 0, // changed
				resource: uri
			}]);
		}));
		this._registeredFiles.set(uri.toString(), file);
		this._onDidChangeFile.fire([{
			type: 1, //created
			resource: uri
		}]);
		return disposableStore;
	}
	async open(resource) {
		try {
			await this.stat(resource);
			const fd = this._fdCounter++;
			this._fileDescriptors.set(fd, {
				resource,
				position: 0
			});
			return fd;
		}catch(e) {
			throw this.handleError(extractErrorMsg(e));
		}
	}
	async close(fd) {
		this._fileDescriptors.delete(fd);
	}
	async read(fd, pos, data, offset, length) {
		const handle = this._fileDescriptors.get(fd);
		if (!handle) {
			throw createFileSystemProviderError('Invalid file descriptor', FileSystemProviderErrorCode.Unavailable);
		}
		try {
			const response = await FileIOService.read({
				path: handle.resource.path,
				position: pos === -1 ? handle.position : pos,
				length: length
			});
			const buffer = new Uint8Array(response.data);
			data.set(buffer, offset);
			if (pos === -1) {
				handle.position += buffer.length;
			}
			return buffer.length;
		}catch(e) {
			throw this.handleError(extractErrorMsg(e));
		}
	}
	async stat(resource) {
		try {
			const response = await FileIOService.getFileStat(resource.path);
			if (!response.status) {
				throw this.handleHttpError(response);
			}
			return response.data;
		}catch(e) {
			throw this.handleError(extractErrorMsg(e));
		}
	}
	async readdir(resource) {
		try {
			const response = await FileIOService.readDirectory(resource.path);
			if (!response.status) {
				throw this.handleHttpError(response);
			}
			const result = [];
			for(const [name, type] of resource.data) {
                result.push([name, type]);
            }
			return result;
		}catch(e) {
			throw this.handleError(extractErrorMsg(e));
		}
	}
	async readFile(resource) {
		const file = this._registeredFiles.get(resource.toString());
		if (!file) {
			throw createFileSystemProviderError('File not found', FileSystemProviderErrorCode.FileNotFound);
		}
		try {
			const response = await FileIOService.readFile(resource.path);
			const buffer = new Uint8Array(response.data);
			if (file) {
				file.mtime = Date.now();
			}
			return buffer;
		}catch(e) {
			throw this.handleError(extractErrorMsg(e));
		}
	}
	readFileStream(resource, opts, token) {
		const stream = newWriteableStream(data => VSBuffer.concat(data.map(d => VSBuffer.wrap(d))).buffer);
		const func = async () => {
			try {
				const response = await FileIOService.readFileStream(resource.path, (progressEvent) => {
					if (token.isCancellationRequested) {
						stream.end();
						return;
					}
				});
				const reader = new Uint8Array(response.data);
				if (token.isCancellationRequested) {
					stream.end();
					return;
				}
				stream.write(reader);
				stream.end();
			}catch(e) {
				stream.error(this.handleError(extractErrorMsg(e)));
				stream.end();
			}	
		}
		func();
		return stream;
	}
	async writeFile(resource, content, opts) {
		const file = this._registeredFiles.get(resource.toString());
		if (!file) {
			throw createFileSystemProviderError('File not found', FileSystemProviderErrorCode.FileNotFound);
		}
		try {
			await FileIOService.writeFile(resource.path, content);
			if (file) {
				file._onDidChange.fire();
			}
			if (!file && opts.create) {
				await this.registerFile(resource);
			}
		}catch(e) {
			throw this.handleError(extractErrorMsg(e));
		}
	}
	async mkdir(resource) {} // this is not needed
	async delete(resource, opts) {} // this is not needed
	async rename(resource, opts) {} // this is not needed
	watch(resource, opts){
		return Disposable.None;
	}
	handleError(response) {
		switch(response.status) {
			case 404:
				return createFileSystemProviderError('File not found', FileSystemProviderErrorCode.FileNotFound);
			case 403:
				return createFileSystemProviderError('Permission deined', FileSystemProviderErrorCode.NoPermissions);
			case 409:
				return createFileSystemProviderError('File exists', FileSystemProviderErrorCode.FileExists);
			default:
				return createFileSystemProviderError('Unkown error', FileSystemProviderErrorCode.Unknown);
		}
	}
}
let fileSystemProvider = null;
const RegisterLocalFileSystemProvider = () => {
	if (fileSystemProvider) {
		return fileSystemProvider;
	}
	fileSystemProvider = new LocalFileSystemProvider();
	registerCustomProvider("file", fileSystemProvider);
	return fileSystemProvider;
}
export {
	RegisterLocalFileSystemProvider,
	RegisterFile
};