Add basic markdown link completions

For #140602

Only normal links for now. Will add reference links later. Should support the forms:

- `[](dir/file.md)`
- `[](./dir/file.md)`
- `[](/root-dir/file.md)`
- `[](#header)`
- `[](./dir/file.md#header)`

extensions/markdown-language-features/src/test/documentLinkProvider.test.ts

@@ -8,17 +8,11 @@ import 'mocha';
 import * as vscode from 'vscode';
 import LinkProvider from '../features/documentLinkProvider';
 import { InMemoryDocument } from './inMemoryDocument';
+import { noopToken } from './util';
 
 
 const testFile = vscode.Uri.joinPath(vscode.workspace.workspaceFolders![0].uri, 'x.md');
 
-const noopToken = new class implements vscode.CancellationToken {
-	private _onCancellationRequestedEmitter = new vscode.EventEmitter<void>();
-	public onCancellationRequested = this._onCancellationRequestedEmitter.event;
-
-	get isCancellationRequested() { return false; }
-};
-
 function getLinksForFile(fileContents: string) {
 	const doc = new InMemoryDocument(testFile, fileContents);
 	const provider = new LinkProvider();

extensions/markdown-language-features/src/test/inMemoryDocument.ts

@@ -51,8 +51,16 @@ export class InMemoryDocument implements vscode.TextDocument {
 		const preCharacters = before.match(/(?<=\r\n|\n|^).*$/g);
 		return new vscode.Position(line, preCharacters ? preCharacters[0].length : 0);
 	}
-	getText(_range?: vscode.Range | undefined): string {
-		return this._contents;
+	getText(range?: vscode.Range): string {
+		if (!range) {
+			return this._contents;
+		}
+
+		if (range.start.line !== range.end.line) {
+			throw new Error('Method not implemented.');
+		}
+
+		return this._lines[range.start.line].slice(range.start.character, range.end.character);
 	}
 	getWordRangeAtPosition(_position: vscode.Position, _regex?: RegExp | undefined): never {
 		throw new Error('Method not implemented.');

extensions/markdown-language-features/src/test/pathCompletion.test.ts

@@ -0,0 +1,112 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as assert from 'assert';
+import 'mocha';
+import * as vscode from 'vscode';
+import { PathCompletionProvider } from '../features/pathCompletions';
+import { createNewMarkdownEngine } from './engine';
+import { InMemoryDocument } from './inMemoryDocument';
+import { CURSOR, getCursorPositions, joinLines, noopToken } from './util';
+
+
+function workspaceFile(...segments: string[]): vscode.Uri {
+	return vscode.Uri.joinPath(vscode.workspace.workspaceFolders![0].uri, ...segments);
+}
+
+function getCompletionsAtCursor(resource: vscode.Uri, fileContents: string) {
+	const doc = new InMemoryDocument(resource, fileContents);
+	const provider = new PathCompletionProvider(createNewMarkdownEngine());
+	const cursorPositions = getCursorPositions(fileContents, doc);
+	return provider.provideCompletionItems(doc, cursorPositions[0], noopToken, {
+		triggerCharacter: undefined,
+		triggerKind: vscode.CompletionTriggerKind.Invoke,
+	});
+}
+
+
+suite('markdown.PathCompletionProvider', () => {
+
+	setup(async () => {
+		// These tests assume that the markdown completion provider is already registered
+		await vscode.extensions.getExtension('vscode.markdown-language-features')!.activate();
+	});
+
+	test('Should not return anything when triggered in empty doc', async () => {
+		const completions = await getCompletionsAtCursor(workspaceFile('new.md'), `${CURSOR}`);
+		assert.strictEqual(completions.length, 0);
+	});
+
+	test('Should return anchor completions', async () => {
+		const completions = await getCompletionsAtCursor(workspaceFile('new.md'), joinLines(
+			`[](#${CURSOR}`,
+			``,
+			`# A b C`,
+			`# x y Z`,
+		));
+
+		assert.strictEqual(completions.length, 2);
+		assert.ok(completions.some(x => x.label === '#a-b-c'), 'Has a-b-c anchor completion');
+		assert.ok(completions.some(x => x.label === '#x-y-z'), 'Has x-y-z anchor completion');
+	});
+
+	test('Should not return suggestions for http links', async () => {
+		const completions = await getCompletionsAtCursor(workspaceFile('new.md'), joinLines(
+			`[](http:${CURSOR}`,
+			``,
+			`# http`,
+			`# http:`,
+			`# https:`,
+		));
+
+		assert.strictEqual(completions.length, 0);
+	});
+
+	test('Should return relative path suggestions', async () => {
+		const completions = await getCompletionsAtCursor(workspaceFile('new.md'), joinLines(
+			`[](${CURSOR}`,
+			``,
+			`# A b C`,
+		));
+
+		assert.ok(completions.some(x => x.label === 'a.md'), 'Has a.md file completion');
+		assert.ok(completions.some(x => x.label === 'b.md'), 'Has b.md file completion');
+		assert.ok(completions.some(x => x.label === 'sub/'), 'Has sub folder completion');
+	});
+
+	test('Should return relative path suggestions using ./', async () => {
+		const completions = await getCompletionsAtCursor(workspaceFile('new.md'), joinLines(
+			`[](./${CURSOR}`,
+			``,
+			`# A b C`,
+		));
+
+		assert.ok(completions.some(x => x.label === 'a.md'), 'Has a.md file completion');
+		assert.ok(completions.some(x => x.label === 'b.md'), 'Has b.md file completion');
+		assert.ok(completions.some(x => x.label === 'sub/'), 'Has sub folder completion');
+	});
+
+	test('Should return absolute path suggestions using /', async () => {
+		const completions = await getCompletionsAtCursor(workspaceFile('sub', 'new.md'), joinLines(
+			`[](/${CURSOR}`,
+			``,
+			`# A b C`,
+		));
+
+		assert.ok(completions.some(x => x.label === 'a.md'), 'Has a.md file completion');
+		assert.ok(completions.some(x => x.label === 'b.md'), 'Has b.md file completion');
+		assert.ok(completions.some(x => x.label === 'sub/'), 'Has sub folder completion');
+		assert.ok(!completions.some(x => x.label === 'c.md'), 'Should not have c.md from sub folder');
+	});
+
+	test('Should return anchor suggestions in other file', async () => {
+		const completions = await getCompletionsAtCursor(workspaceFile('sub', 'new.md'), joinLines(
+			`[](/b.md#${CURSOR}`,
+		));
+
+		assert.ok(completions.some(x => x.label === '#b'), 'Has #b header completion');
+		assert.ok(completions.some(x => x.label === '#header1'), 'Has #header1 header completion');
+	});
+});

extensions/markdown-language-features/src/test/smartSelect.test.ts

@@ -8,9 +8,7 @@ import * as vscode from 'vscode';
 import MarkdownSmartSelect from '../features/smartSelect';
 import { createNewMarkdownEngine } from './engine';
 import { InMemoryDocument } from './inMemoryDocument';
-import { joinLines } from './util';
-
-const CURSOR = '$$CURSOR$$';
+import { CURSOR, getCursorPositions, joinLines } from './util';
 
 const testFileName = vscode.Uri.file('test.md');
 
@@ -672,17 +670,3 @@ async function getSelectionRangesForDocument(contents: string, pos?: vscode.Posi
 	const positions = pos ? pos : getCursorPositions(contents, doc);
 	return await provider.provideSelectionRanges(doc, positions, new vscode.CancellationTokenSource().token);
 }
-
-let getCursorPositions = (contents: string, doc: InMemoryDocument): vscode.Position[] => {
-	let positions: vscode.Position[] = [];
-	let index = 0;
-	let wordLength = 0;
-	while (index !== -1) {
-		index = contents.indexOf(CURSOR, index + wordLength);
-		if (index !== -1) {
-			positions.push(doc.positionAt(index));
-		}
-		wordLength = CURSOR.length;
-	}
-	return positions;
-};

extensions/markdown-language-features/src/test/util.ts

@@ -3,6 +3,31 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 import * as os from 'os';
+import * as vscode from 'vscode';
+import { InMemoryDocument } from './inMemoryDocument';
 
 export const joinLines = (...args: string[]) =>
 	args.join(os.platform() === 'win32' ? '\r\n' : '\n');
+
+export const noopToken = new class implements vscode.CancellationToken {
+	_onCancellationRequestedEmitter = new vscode.EventEmitter<void>();
+	onCancellationRequested = this._onCancellationRequestedEmitter.event;
+
+	get isCancellationRequested() { return false; }
+};
+
+export const CURSOR = '$$CURSOR$$';
+
+export function getCursorPositions(contents: string, doc: InMemoryDocument): vscode.Position[] {
+	let positions: vscode.Position[] = [];
+	let index = 0;
+	let wordLength = 0;
+	while (index !== -1) {
+		index = contents.indexOf(CURSOR, index + wordLength);
+		if (index !== -1) {
+			positions.push(doc.positionAt(index));
+		}
+		wordLength = CURSOR.length;
+	}
+	return positions;
+}