Merge branch 'master' into octref/html-path-completion

extensions/html/server/src/htmlServerMain.ts

@@ -20,6 +20,8 @@ import { formatError, runSafe } from './utils/errors';
 import { doComplete as emmetDoComplete, updateExtensionsPath as updateEmmetExtensionsPath, getEmmetCompletionParticipants } from 'vscode-emmet-helper';
 import { getPathCompletionParticipant } from './modes/pathCompletion';
 
+import { FoldingRangesRequest, FoldingProviderServerCapabilities } from './protocol/foldingProvider.proposed';
+
 namespace TagCloseRequest {
 	export const type: RequestType<TextDocumentPositionParams, string | null, any, any> = new RequestType('html/tag');
 }
@@ -33,6 +35,9 @@ console.error = connection.console.error.bind(connection.console);
 process.on('unhandledRejection', (e: any) => {
 	connection.console.error(formatError(`Unhandled exception`, e));
 });
+process.on('uncaughtException', (e) => {
+	connection.console.error(formatError(`Unhandled exception`, e));
+});
 
 // Create a simple text document manager. The text document manager
 // supports full document sync only
@@ -108,7 +113,7 @@ connection.onInitialize((params: InitializeParams): InitializeResult => {
 	clientDynamicRegisterSupport = hasClientCapability('workspace', 'symbol', 'dynamicRegistration');
 	scopedSettingsSupport = hasClientCapability('workspace', 'configuration');
 	workspaceFoldersSupport = hasClientCapability('workspace', 'workspaceFolders');
-	let capabilities: ServerCapabilities & CPServerCapabilities = {
+	let capabilities: ServerCapabilities & CPServerCapabilities & FoldingProviderServerCapabilities = {
 		// Tell the client that the server works in FULL text document sync mode
 		textDocumentSync: documents.syncKind,
 		completionProvider: clientSnippetSupport ? { resolveProvider: true, triggerCharacters: [...emmetTriggerCharacters, '.', ':', '<', '"', '=', '/'] } : undefined,
@@ -120,7 +125,8 @@ connection.onInitialize((params: InitializeParams): InitializeResult => {
 		definitionProvider: true,
 		signatureHelpProvider: { triggerCharacters: ['('] },
 		referencesProvider: true,
-		colorProvider: true
+		colorProvider: true,
+		foldingProvider: true
 	};
 	return { capabilities };
 });
@@ -456,6 +462,20 @@ connection.onRequest(TagCloseRequest.type, params => {
 	}, null, `Error while computing tag close actions for ${params.textDocument.uri}`);
 });
 
+connection.onRequest(FoldingRangesRequest.type, params => {
+	return runSafe(() => {
+		let document = documents.get(params.textDocument.uri);
+		if (document) {
+			let mode = languageModes.getMode('html');
+			if (mode && mode.getFoldingRanges) {
+				return mode.getFoldingRanges(document);
+			}
+			return null;
+		}
+		return null;
+	}, null, `Error while computing folding regions for ${params.textDocument.uri}`);
+});
+
 
 // Listen on the connection
 connection.listen();

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

@@ -9,6 +9,8 @@ import { LanguageService as HTMLLanguageService, HTMLDocument, DocumentContext,
 import { TextDocument, Position, Range } from 'vscode-languageserver-types';
 import { LanguageMode, Settings } from './languageModes';
 
+import { FoldingRangeType, FoldingRange, FoldingRangeList } from '../protocol/foldingProvider.proposed';
+
 export function getHTMLMode(htmlLanguageService: HTMLLanguageService): LanguageMode {
 	let globalSettings: Settings = {};
 	let htmlDocuments = getLanguageModelCache<HTMLDocument>(10, 60, document => htmlLanguageService.parseHTMLDocument(document));
@@ -62,6 +64,80 @@ export function getHTMLMode(htmlLanguageService: HTMLLanguageService): LanguageM
 			formatSettings = merge(formatParams, formatSettings);
 			return htmlLanguageService.format(document, range, formatSettings);
 		},
+		getFoldingRanges(document: TextDocument): FoldingRangeList {
+			const scanner = htmlLanguageService.createScanner(document.getText());
+			let token = scanner.scan();
+			let ranges: FoldingRange[] = [];
+			let stack: FoldingRange[] = [];
+			let elementNames: string[] = [];
+			let lastTagName = null;
+			let prevStart = -1;
+			while (token !== TokenType.EOS) {
+				switch (token) {
+					case TokenType.StartTagOpen: {
+						let startLine = document.positionAt(scanner.getTokenOffset()).line;
+						let range = { startLine, endLine: startLine };
+						stack.push(range);
+						break;
+					}
+					case TokenType.StartTag: {
+						lastTagName = scanner.getTokenText();
+						elementNames.push(lastTagName);
+						break;
+					}
+					case TokenType.EndTag: {
+						lastTagName = scanner.getTokenText();
+						break;
+					}
+					case TokenType.EndTagClose:
+					case TokenType.StartTagSelfClose: {
+						let name = elementNames.pop();
+						let range = stack.pop();
+						while (name && name !== lastTagName) {
+							name = elementNames.pop();
+							range = stack.pop();
+						}
+						let line = document.positionAt(scanner.getTokenOffset()).line;
+						if (range && line > range.startLine + 1 && prevStart !== range.startLine) {
+							range.endLine = line - 1;
+							ranges.push(range);
+							prevStart = range.startLine;
+						}
+						break;
+					}
+					case TokenType.Comment: {
+						let text = scanner.getTokenText();
+						let m = text.match(/^\s*#(region\b)|(endregion\b)/);
+						if (m) {
+							let line = document.positionAt(scanner.getTokenOffset()).line;
+							if (m[1]) { // start pattern match
+								let range = { startLine: line, endLine: line, type: FoldingRangeType.Region };
+								stack.push(range);
+								elementNames.push('');
+							} else {
+								let i = stack.length - 1;
+								while (i >= 0 && stack[i].type !== FoldingRangeType.Region) {
+									i--;
+								}
+								if (i >= 0) {
+									let range = stack[i];
+									stack.length = i;
+									if (line > range.startLine && prevStart !== range.startLine) {
+										range.endLine = line;
+										ranges.push(range);
+										prevStart = range.startLine;
+									}
+								}
+							}
+						}
+						break;
+					}
+				}
+				token = scanner.scan();
+			}
+			return <FoldingRangeList>{ ranges };
+		},
+
 		doAutoClose(document: TextDocument, position: Position) {
 			let offset = document.offsetAt(position);
 			let text = document.getText();

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

@@ -20,6 +20,8 @@ import { getHTMLMode } from './htmlMode';
 
 export { ColorInformation, ColorPresentation, Color };
 
+import { FoldingRangeList } from '../protocol/foldingProvider.proposed';
+
 export interface Settings {
 	css?: any;
 	html?: any;
@@ -49,6 +51,7 @@ export interface LanguageMode {
 	findDocumentColors?: (document: TextDocument) => ColorInformation[];
 	getColorPresentations?: (document: TextDocument, color: Color, range: Range) => ColorPresentation[];
 	doAutoClose?: (document: TextDocument, position: Position) => string | null;
+	getFoldingRanges?: (document: TextDocument) => FoldingRangeList | null;
 	onDocumentRemoved(document: TextDocument): void;
 	dispose(): void;
 }

extensions/html/server/src/protocol/foldingProvider.proposed.ts

@@ -0,0 +1,89 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { TextDocumentIdentifier } from 'vscode-languageserver-types';
+import { RequestType, TextDocumentRegistrationOptions, StaticRegistrationOptions } from 'vscode-languageserver-protocol';
+
+// ---- capabilities
+
+export interface FoldingProviderClientCapabilities {
+	/**
+	 * The text document client capabilities
+	 */
+	textDocument?: {
+		/**
+		 * Capabilities specific to the foldingProvider
+		 */
+		foldingProvider?: {
+			/**
+			 * Whether implementation supports dynamic registration. If this is set to `true`
+			 * the client supports the new `(FoldingProviderOptions & TextDocumentRegistrationOptions & StaticRegistrationOptions)`
+			 * return value for the corresponding server capability as well.
+			 */
+			dynamicRegistration?: boolean;
+		};
+	};
+}
+
+export interface FoldingProviderOptions {
+}
+
+export interface FoldingProviderServerCapabilities {
+	/**
+	 * The server provides folding provider support.
+	 */
+	foldingProvider?: FoldingProviderOptions | (FoldingProviderOptions & TextDocumentRegistrationOptions & StaticRegistrationOptions);
+}
+
+export interface FoldingRangeList {
+	/**
+	 * The folding ranges.
+	 */
+	ranges: FoldingRange[];
+}
+
+export enum FoldingRangeType {
+	/**
+	 * Folding range for a comment
+	 */
+	Comment = 'comment',
+	/**
+	 * Folding range for a imports or includes
+	 */
+	Imports = 'imports',
+	/**
+	 * Folding range for a region (e.g. `#region`)
+	 */
+	Region = 'region'
+}
+
+export interface FoldingRange {
+
+	/**
+	 * The start line number
+	 */
+	startLine: number;
+
+	/**
+	 * The end line number
+	 */
+	endLine: number;
+
+	/**
+	 * The actual color value for this folding range.
+	 */
+	type?: FoldingRangeType | string;
+}
+
+export interface FoldingRangeRequestParam {
+	/**
+	 * The text document.
+	 */
+	textDocument: TextDocumentIdentifier;
+}
+
+export namespace FoldingRangesRequest {
+	export const type: RequestType<FoldingRangeRequestParam, FoldingRangeList | null, any, any> = new RequestType('textDocument/foldingRanges');
+}

extensions/html/server/tsconfig.json

@@ -8,5 +8,8 @@
 		"lib": [
 			"es5", "es2015.promise"
 		]
-	}
+	},
+	"include": [
+		"src"
+	]
 }

extensions/html/server/yarn.lock

@@ -56,7 +56,7 @@ vscode-languageserver-types@^3.6.0-next.1:
   version "3.6.0-next.1"
   resolved "https://registry.yarnpkg.com/vscode-languageserver-types/-/vscode-languageserver-types-3.6.0-next.1.tgz#98e488d3f87b666b4ee1a3d89f0023e246d358f3"
 
-vscode-languageserver@^4.0.0-next.4:
+vscode-languageserver@4.0.0-next.4:
   version "4.0.0-next.4"
   resolved "https://registry.yarnpkg.com/vscode-languageserver/-/vscode-languageserver-4.0.0-next.4.tgz#162440b15bedaab07e1676f046e4d9b8578b3d92"
   dependencies: