[html] add multiroot support. Fixes #32489

extensions/html/server/src/htmlServerMain.ts

@@ -4,10 +4,12 @@
  *--------------------------------------------------------------------------------------------*/
 'use strict';
 
-import { createConnection, IConnection, TextDocuments, InitializeParams, InitializeResult, RequestType, DocumentRangeFormattingRequest, Disposable, DocumentSelector } from 'vscode-languageserver';
+import { createConnection, IConnection, TextDocuments, InitializeParams, InitializeResult, RequestType, DocumentRangeFormattingRequest, Disposable, DocumentSelector, GetConfigurationParams } from 'vscode-languageserver';
 import { DocumentContext } from 'vscode-html-languageservice';
 import { TextDocument, Diagnostic, DocumentLink, Range, SymbolInformation } from 'vscode-languageserver-types';
-import { getLanguageModes, LanguageModes } from './modes/languageModes';
+import { getLanguageModes, LanguageModes, Settings } from './modes/languageModes';
+
+import { GetConfigurationRequest } from 'vscode-languageserver/lib/protocol.proposed';
 
 import { format } from './modes/formatting';
 import { pushAll } from './utils/arrays';
@@ -38,10 +40,27 @@ documents.listen(connection);
 
 let workspacePath: string;
 var languageModes: LanguageModes;
-var settings: any = {};
 
 let clientSnippetSupport = false;
 let clientDynamicRegisterSupport = false;
+let scopedSettingsSupport = false;
+
+var globalSettings: Settings = {};
+let documentSettings: { [key: string]: Thenable<Settings> } = {};
+
+function getDocumentSettings(textDocument: TextDocument, needsDocumentSettings: () => boolean): Thenable<Settings> {
+	if (scopedSettingsSupport && needsDocumentSettings()) {
+		let promise = documentSettings[textDocument.uri];
+		if (!promise) {
+			let scopeUri = textDocument.uri;
+			let configRequestParam: GetConfigurationParams = { items: [{ scopeUri, section: 'css' }, { scopeUri, section: 'html' }, { scopeUri, section: 'javascript' }] };
+			promise = connection.sendRequest(GetConfigurationRequest.type, configRequestParam).then(s => ({ css: s[0], html: s[1], javascript: s[2] }));
+			documentSettings[textDocument.uri] = promise;
+		}
+		return promise;
+	}
+	return Promise.resolve(void 0);
+}
 
 // After the server has started the client sends an initilize request. The server receives
 // in the passed params the rootPath of the workspace plus the client capabilites
@@ -68,6 +87,7 @@ connection.onInitialize((params: InitializeParams): InitializeResult => {
 
 	clientSnippetSupport = hasClientCapability('textDocument', 'completion', 'completionItem', 'snippetSupport');
 	clientDynamicRegisterSupport = hasClientCapability('workspace', 'symbol', 'dynamicRegistration');
+	scopedSettingsSupport = hasClientCapability('workspace', 'configuration');
 	return {
 		capabilities: {
 			// Tell the client that the server works in FULL text document sync mode
@@ -85,21 +105,13 @@ connection.onInitialize((params: InitializeParams): InitializeResult => {
 	};
 });
 
-let validation = {
-	html: true,
-	css: true,
-	javascript: true
-};
-
 let formatterRegistration: Thenable<Disposable> = null;
 
 // The settings have changed. Is send on server activation as well.
 connection.onDidChangeConfiguration((change) => {
-	settings = change.settings;
-	let validationSettings = settings && settings.html && settings.html.validate || {};
-	validation.css = validationSettings.styles !== false;
-	validation.javascript = validationSettings.scripts !== false;
+	globalSettings = change.settings;
 
+	documentSettings = {}; // reset all document settings
 	languageModes.getAllModes().forEach(m => {
 		if (m.configure) {
 			m.configure(change.settings);
@@ -109,7 +121,7 @@ connection.onDidChangeConfiguration((change) => {
 
 	// dynamically enable & disable the formatter
 	if (clientDynamicRegisterSupport) {
-		let enableFormatter = settings && settings.html && settings.html.format && settings.html.format.enable;
+		let enableFormatter = globalSettings && globalSettings.html && globalSettings.html.format && globalSettings.html.format.enable;
 		if (enableFormatter) {
 			if (!formatterRegistration) {
 				let documentSelector: DocumentSelector = [{ language: 'html' }, { language: 'handlebars' }]; // don't register razor, the formatter does more harm than good
@@ -154,26 +166,37 @@ function triggerValidation(textDocument: TextDocument): void {
 	}, validationDelayMs);
 }
 
-function validateTextDocument(textDocument: TextDocument): void {
+function isValidationEnabled(languageId: string, settings: Settings = globalSettings) {
+	let validationSettings = settings && settings.html && settings.html.validate;
+	if (validationSettings) {
+		return languageId === 'css' && validationSettings.styles !== false || languageId === 'javascript' && validationSettings.scripts !== false;
+	}
+	return true;
+}
+
+async function validateTextDocument(textDocument: TextDocument) {
 	let diagnostics: Diagnostic[] = [];
 	if (textDocument.languageId === 'html') {
-		languageModes.getAllModesInDocument(textDocument).forEach(mode => {
-			if (mode.doValidation && validation[mode.getId()]) {
-				pushAll(diagnostics, mode.doValidation(textDocument));
+		let modes = languageModes.getAllModesInDocument(textDocument);
+		let settings = await getDocumentSettings(textDocument, () => modes.some(m => m.doValidation && m.doValidation.length > 1));
+		modes.forEach(mode => {
+			if (mode.doValidation && isValidationEnabled(mode.getId(), settings)) {
+				pushAll(diagnostics, mode.doValidation(textDocument, settings));
 			}
 		});
 	}
 	connection.sendDiagnostics({ uri: textDocument.uri, diagnostics });
 }
 
-connection.onCompletion(textDocumentPosition => {
+connection.onCompletion(async textDocumentPosition => {
 	let document = documents.get(textDocumentPosition.textDocument.uri);
 	let mode = languageModes.getModeAtPosition(document, textDocumentPosition.position);
 	if (mode && mode.doComplete) {
 		if (mode.getId() !== 'html') {
 			connection.telemetry.logEvent({ key: 'html.embbedded.complete', value: { languageId: mode.getId() } });
 		}
-		return mode.doComplete(document, textDocumentPosition.position);
+		let settings = await getDocumentSettings(document, () => mode.doComplete.length > 2);
+		return mode.doComplete(document, textDocumentPosition.position, settings);
 	}
 	return { isIncomplete: true, items: [] };
 });
@@ -235,13 +258,16 @@ connection.onSignatureHelp(signatureHelpParms => {
 	return null;
 });
 
-connection.onDocumentRangeFormatting(formatParams => {
+connection.onDocumentRangeFormatting(async formatParams => {
 	let document = documents.get(formatParams.textDocument.uri);
-
+	let settings = await getDocumentSettings(document, () => true);
+	if (!settings) {
+		settings = globalSettings;
+	}
 	let unformattedTags: string = settings && settings.html && settings.html.format && settings.html.format.unformatted || '';
 	let enabledModes = { css: !unformattedTags.match(/\bstyle\b/), javascript: !unformattedTags.match(/\bscript\b/) };
 
-	return format(languageModes, document, formatParams.range, formatParams.options, enabledModes);
+	return format(languageModes, document, formatParams.range, formatParams.options, settings, enabledModes);
 });
 
 connection.onDocumentLinks(documentLinkParam => {

extensions/html/server/src/modes/cssMode.ts

@@ -7,7 +7,7 @@
 import { LanguageModelCache, getLanguageModelCache } from '../languageModelCache';
 import { TextDocument, Position } from 'vscode-languageserver-types';
 import { getCSSLanguageService, Stylesheet } from 'vscode-css-languageservice';
-import { LanguageMode } from './languageModes';
+import { LanguageMode, Settings } from './languageModes';
 import { HTMLDocumentRegions, CSS_STYLE_RULE } from './embeddedSupport';
 
 export function getCSSMode(documentRegions: LanguageModelCache<HTMLDocumentRegions>): LanguageMode {
@@ -22,9 +22,9 @@ export function getCSSMode(documentRegions: LanguageModelCache<HTMLDocumentRegio
 		configure(options: any) {
 			cssLanguageService.configure(options && options.css);
 		},
-		doValidation(document: TextDocument) {
+		doValidation(document: TextDocument, settings: Settings) {
 			let embedded = embeddedCSSDocuments.get(document);
-			return cssLanguageService.doValidation(embedded, cssStylesheets.get(embedded));
+			return cssLanguageService.doValidation(embedded, cssStylesheets.get(embedded), settings && settings.css);
 		},
 		doComplete(document: TextDocument, position: Position) {
 			let embedded = embeddedCSSDocuments.get(document);

extensions/html/server/src/modes/formatting.ts

@@ -6,11 +6,11 @@
 
 import { applyEdits } from '../utils/edits';
 import { TextDocument, Range, TextEdit, FormattingOptions, Position } from 'vscode-languageserver-types';
-import { LanguageModes } from './languageModes';
+import { LanguageModes, Settings } from './languageModes';
 import { pushAll } from '../utils/arrays';
 import { isEOL } from '../utils/strings';
 
-export function format(languageModes: LanguageModes, document: TextDocument, formatRange: Range, formattingOptions: FormattingOptions, enabledModes: { [mode: string]: boolean }) {
+export function format(languageModes: LanguageModes, document: TextDocument, formatRange: Range, formattingOptions: FormattingOptions, settings: Settings, enabledModes: { [mode: string]: boolean }) {
 	let result: TextEdit[] = [];
 
 	let endPos = formatRange.end;
@@ -40,7 +40,7 @@ export function format(languageModes: LanguageModes, document: TextDocument, for
 	while (i < allRanges.length && allRanges[i].mode.getId() !== 'html') {
 		let range = allRanges[i];
 		if (!range.attributeValue && range.mode.format) {
-			let edits = range.mode.format(document, Range.create(startPos, range.end), formattingOptions);
+			let edits = range.mode.format(document, Range.create(startPos, range.end), formattingOptions, settings);
 			pushAll(result, edits);
 		}
 		startPos = range.end;
@@ -54,7 +54,7 @@ export function format(languageModes: LanguageModes, document: TextDocument, for
 
 	// perform a html format and apply changes to a new document
 	let htmlMode = languageModes.getMode('html');
-	let htmlEdits = htmlMode.format(document, formatRange, formattingOptions);
+	let htmlEdits = htmlMode.format(document, formatRange, formattingOptions, settings);
 	let htmlFormattedContent = applyEdits(document, htmlEdits);
 	let newDocument = TextDocument.create(document.uri + '.tmp', document.languageId, document.version, htmlFormattedContent);
 	try {
@@ -68,7 +68,7 @@ export function format(languageModes: LanguageModes, document: TextDocument, for
 		for (let r of embeddedRanges) {
 			let mode = r.mode;
 			if (mode && mode.format && enabledModes[mode.getId()] && !r.attributeValue) {
-				let edits = mode.format(newDocument, r, formattingOptions);
+				let edits = mode.format(newDocument, r, formattingOptions, settings);
 				for (let edit of edits) {
 					embeddedEdits.push(edit);
 				}

extensions/html/server/src/modes/htmlMode.ts

@@ -7,20 +7,20 @@
 import { getLanguageModelCache } from '../languageModelCache';
 import { LanguageService as HTMLLanguageService, HTMLDocument, DocumentContext, FormattingOptions } from 'vscode-html-languageservice';
 import { TextDocument, Position, Range } from 'vscode-languageserver-types';
-import { LanguageMode } from './languageModes';
+import { LanguageMode, Settings } from './languageModes';
 
 export function getHTMLMode(htmlLanguageService: HTMLLanguageService): LanguageMode {
-	let settings: any = {};
+	let globalSettings: Settings = {};
 	let htmlDocuments = getLanguageModelCache<HTMLDocument>(10, 60, document => htmlLanguageService.parseHTMLDocument(document));
 	return {
 		getId() {
 			return 'html';
 		},
 		configure(options: any) {
-			settings = options && options.html;
+			globalSettings = options;
 		},
-		doComplete(document: TextDocument, position: Position) {
-			let options = settings && settings.suggest;
+		doComplete(document: TextDocument, position: Position, settings: Settings = globalSettings) {
+			let options = settings && settings.html && settings.html.suggest;
 			return htmlLanguageService.doComplete(document, position, htmlDocuments.get(document), options);
 		},
 		doHover(document: TextDocument, position: Position) {
@@ -35,8 +35,8 @@ export function getHTMLMode(htmlLanguageService: HTMLLanguageService): LanguageM
 		findDocumentSymbols(document: TextDocument) {
 			return htmlLanguageService.findDocumentSymbols(document, htmlDocuments.get(document));
 		},
-		format(document: TextDocument, range: Range, formatParams: FormattingOptions) {
-			let formatSettings = settings && settings.format;
+		format(document: TextDocument, range: Range, formatParams: FormattingOptions, settings: Settings = globalSettings) {
+			let formatSettings = settings && settings.html && settings.html.format;
 			if (!formatSettings) {
 				formatSettings = formatParams;
 			} else {

extensions/html/server/src/modes/javascriptMode.ts

@@ -6,7 +6,7 @@
 
 import { LanguageModelCache, getLanguageModelCache } from '../languageModelCache';
 import { SymbolInformation, SymbolKind, CompletionItem, Location, SignatureHelp, SignatureInformation, ParameterInformation, Definition, TextEdit, TextDocument, Diagnostic, DiagnosticSeverity, Range, CompletionItemKind, Hover, MarkedString, DocumentHighlight, DocumentHighlightKind, CompletionList, Position, FormattingOptions } from 'vscode-languageserver-types';
-import { LanguageMode } from './languageModes';
+import { LanguageMode, Settings } from './languageModes';
 import { getWordAtText, startsWith, isWhitespaceOnly, repeat } from '../utils/strings';
 import { HTMLDocumentRegions } from './embeddedSupport';
 
@@ -60,14 +60,14 @@ export function getJavascriptMode(documentRegions: LanguageModelCache<HTMLDocume
 	};
 	let jsLanguageService = ts.createLanguageService(host);
 
-	let settings: any = {};
+	let globalSettings: Settings = {};
 
 	return {
 		getId() {
 			return 'javascript';
 		},
 		configure(options: any) {
-			settings = options && options.javascript;
+			globalSettings = options;
 		},
 		doValidation(document: TextDocument): Diagnostic[] {
 			updateCurrentTextDocument(document);
@@ -242,12 +242,14 @@ export function getJavascriptMode(documentRegions: LanguageModelCache<HTMLDocume
 			}
 			return null;
 		},
-		format(document: TextDocument, range: Range, formatParams: FormattingOptions): TextEdit[] {
+		format(document: TextDocument, range: Range, formatParams: FormattingOptions, settings: Settings = globalSettings): TextEdit[] {
 			currentTextDocument = documentRegions.get(document).getEmbeddedDocument('javascript', true);
 			scriptFileVersion++;
 
+			let formatterSettings = settings && settings.javascript && settings.javascript.format;
+
 			let initialIndentLevel = computeInitialIndent(document, range, formatParams);
-			let formatSettings = convertOptions(formatParams, settings && settings.format, initialIndentLevel + 1);
+			let formatSettings = convertOptions(formatParams, formatterSettings, initialIndentLevel + 1);
 			let start = currentTextDocument.offsetAt(range.start);
 			let end = currentTextDocument.offsetAt(range.end);
 			let lastLineRange = null;

extensions/html/server/src/modes/languageModes.ts

@@ -16,11 +16,21 @@ import { getCSSMode } from './cssMode';
 import { getJavascriptMode } from './javascriptMode';
 import { getHTMLMode } from './htmlMode';
 
+export interface Settings {
+	css?: any;
+	html?: any;
+	javascript?: any;
+}
+
+export interface SettingProvider {
+	getDocumentSettings(textDocument: TextDocument): Thenable<Settings>;
+}
+
 export interface LanguageMode {
 	getId();
-	configure?: (options: any) => void;
-	doValidation?: (document: TextDocument) => Diagnostic[];
-	doComplete?: (document: TextDocument, position: Position) => CompletionList;
+	configure?: (options: Settings) => void;
+	doValidation?: (document: TextDocument, settings?: Settings) => Diagnostic[];
+	doComplete?: (document: TextDocument, position: Position, settings?: Settings) => CompletionList;
 	doResolve?: (document: TextDocument, item: CompletionItem) => CompletionItem;
 	doHover?: (document: TextDocument, position: Position) => Hover;
 	doSignatureHelp?: (document: TextDocument, position: Position) => SignatureHelp;
@@ -29,7 +39,7 @@ export interface LanguageMode {
 	findDocumentLinks?: (document: TextDocument, documentContext: DocumentContext) => DocumentLink[];
 	findDefinition?: (document: TextDocument, position: Position) => Definition;
 	findReferences?: (document: TextDocument, position: Position) => Location[];
-	format?: (document: TextDocument, range: Range, options: FormattingOptions) => TextEdit[];
+	format?: (document: TextDocument, range: Range, options: FormattingOptions, settings: Settings) => TextEdit[];
 	findColorSymbols?: (document: TextDocument) => Range[];
 	onDocumentRemoved(document: TextDocument): void;
 	dispose(): void;

extensions/html/server/src/test/formatting.test.ts

@@ -38,7 +38,7 @@ suite('HTML Embedded Formatting', () => {
 			formatOptions = FormattingOptions.create(2, true);
 		}
 
-		let result = format(languageModes, document, range, formatOptions, { css: true, javascript: true });
+		let result = format(languageModes, document, range, formatOptions, void 0, { css: true, javascript: true });
 
 		let actual = applyEdits(document, result);
 		assert.equal(actual, expected, message);

extensions/html/server/src/test/javascriptMode.test.ts

@@ -6,7 +6,7 @@
 
 import * as assert from 'assert';
 import { getJavascriptMode } from '../modes/javascriptMode';
-import { TextDocument, Range, TextEdit, FormattingOptions } from 'vscode-languageserver-types';
+import { TextDocument } from 'vscode-languageserver-types';
 import { getLanguageModelCache } from '../languageModelCache';
 
 import { getLanguageService } from 'vscode-html-languageservice';