Rename types in the markdown extension (microsoft#152905)

Renames in the markdown extension

This renames some types and splits up some files as part of an exploration towards a proper LSP. Changes:

- `SkinnyTextDocument` -> `ITextDocument`
- Moved `ITextDocument` to own file
- `MdWorkspaceContents` -> `IMdWorkspace`

Author: mjbvz

extensions/markdown-language-features/src/commands/renderDocument.ts

@@ -5,7 +5,7 @@
 
 import { Command } from '../commandManager';
 import { MarkdownItEngine } from '../markdownEngine';
-import { SkinnyTextDocument } from '../workspaceContents';
+import { ITextDocument } from '../types/textDocument';
 
 export class RenderDocument implements Command {
 	public readonly id = 'markdown.api.render';
@@ -14,7 +14,7 @@ export class RenderDocument implements Command {
 		private readonly engine: MarkdownItEngine
 	) { }
 
-	public async execute(document: SkinnyTextDocument | string): Promise<string> {
+	public async execute(document: ITextDocument | string): Promise<string> {
 		return (await (this.engine.render(document))).html;
 	}
 }

extensions/markdown-language-features/src/extension.ts

@@ -28,7 +28,7 @@ import { ContentSecurityPolicyArbiter, ExtensionContentSecurityPolicyArbiter, Pr
 import { githubSlugifier } from './slugify';
 import { MdTableOfContentsProvider } from './tableOfContents';
 import { loadDefaultTelemetryReporter, TelemetryReporter } from './telemetryReporter';
-import { MdWorkspaceContents, VsCodeMdWorkspaceContents } from './workspaceContents';
+import { IMdWorkspace, VsCodeMdWorkspace } from './workspace';
 
 
 export function activate(context: vscode.ExtensionContext) {
@@ -45,16 +45,16 @@ export function activate(context: vscode.ExtensionContext) {
 	const commandManager = new CommandManager();
 
 	const engine = new MarkdownItEngine(contributions, githubSlugifier, logger);
-	const workspaceContents = new VsCodeMdWorkspaceContents();
-	const parser = new MdParsingProvider(engine, workspaceContents);
-	const tocProvider = new MdTableOfContentsProvider(parser, workspaceContents, logger);
-	context.subscriptions.push(workspaceContents, parser, tocProvider);
+	const workspace = new VsCodeMdWorkspace();
+	const parser = new MdParsingProvider(engine, workspace);
+	const tocProvider = new MdTableOfContentsProvider(parser, workspace, logger);
+	context.subscriptions.push(workspace, parser, tocProvider);
 
 	const contentProvider = new MdDocumentRenderer(engine, context, cspArbiter, contributions, logger);
 	const previewManager = new MarkdownPreviewManager(contentProvider, logger, contributions, tocProvider);
 	context.subscriptions.push(previewManager);
 
-	context.subscriptions.push(registerMarkdownLanguageFeatures(parser, workspaceContents, commandManager, tocProvider, logger));
+	context.subscriptions.push(registerMarkdownLanguageFeatures(parser, workspace, commandManager, tocProvider, logger));
 	context.subscriptions.push(registerMarkdownCommands(commandManager, previewManager, telemetryReporter, cspArbiter, engine, tocProvider));
 
 	context.subscriptions.push(vscode.workspace.onDidChangeConfiguration(() => {
@@ -64,15 +64,15 @@ export function activate(context: vscode.ExtensionContext) {
 
 function registerMarkdownLanguageFeatures(
 	parser: IMdParser,
-	workspaceContents: MdWorkspaceContents,
+	workspace: IMdWorkspace,
 	commandManager: CommandManager,
 	tocProvider: MdTableOfContentsProvider,
 	logger: ILogger,
 ): vscode.Disposable {
 	const selector: vscode.DocumentSelector = { language: 'markdown', scheme: '*' };
 
-	const linkProvider = new MdLinkProvider(parser, workspaceContents, logger);
-	const referencesProvider = new MdReferencesProvider(parser, workspaceContents, tocProvider, logger);
+	const linkProvider = new MdLinkProvider(parser, workspace, logger);
+	const referencesProvider = new MdReferencesProvider(parser, workspace, tocProvider, logger);
 	const symbolProvider = new MdDocumentSymbolProvider(tocProvider, logger);
 
 	return vscode.Disposable.from(
@@ -81,7 +81,7 @@ function registerMarkdownLanguageFeatures(
 
 		// Language features
 		registerDefinitionSupport(selector, referencesProvider),
-		registerDiagnosticSupport(selector, workspaceContents, linkProvider, commandManager, referencesProvider, tocProvider, logger),
+		registerDiagnosticSupport(selector, workspace, linkProvider, commandManager, referencesProvider, tocProvider, logger),
 		registerDocumentLinkSupport(selector, linkProvider),
 		registerDocumentSymbolSupport(selector, tocProvider, logger),
 		registerDropIntoEditorSupport(selector),
@@ -90,9 +90,9 @@ function registerMarkdownLanguageFeatures(
 		registerPasteSupport(selector),
 		registerPathCompletionSupport(selector, parser, linkProvider),
 		registerReferencesSupport(selector, referencesProvider),
-		registerRenameSupport(selector, workspaceContents, referencesProvider, parser.slugifier),
+		registerRenameSupport(selector, workspace, referencesProvider, parser.slugifier),
 		registerSmartSelectSupport(selector, parser, tocProvider),
-		registerWorkspaceSymbolSupport(workspaceContents, symbolProvider),
+		registerWorkspaceSymbolSupport(workspace, symbolProvider),
 	);
 }
 

extensions/markdown-language-features/src/languageFeatures/definitions.ts

@@ -3,7 +3,7 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 import * as vscode from 'vscode';
-import { SkinnyTextDocument } from '../workspaceContents';
+import { ITextDocument } from '../types/textDocument';
 import { MdReferencesProvider } from './references';
 
 export class MdVsCodeDefinitionProvider implements vscode.DefinitionProvider {
@@ -12,7 +12,7 @@ export class MdVsCodeDefinitionProvider implements vscode.DefinitionProvider {
 		private readonly referencesProvider: MdReferencesProvider,
 	) { }
 
-	async provideDefinition(document: SkinnyTextDocument, position: vscode.Position, token: vscode.CancellationToken): Promise<vscode.Definition | undefined> {
+	async provideDefinition(document: ITextDocument, position: vscode.Position, token: vscode.CancellationToken): Promise<vscode.Definition | undefined> {
 		const allRefs = await this.referencesProvider.getReferencesAtPosition(document, position, token);
 
 		return allRefs.find(ref => ref.kind === 'link' && ref.isDefinition)?.location;

extensions/markdown-language-features/src/languageFeatures/diagnostics.ts

@@ -9,14 +9,15 @@ import * as nls from 'vscode-nls';
 import { CommandManager } from '../commandManager';
 import { ILogger } from '../logging';
 import { MdTableOfContentsProvider } from '../tableOfContents';
+import { ITextDocument } from '../types/textDocument';
 import { Delayer } from '../util/async';
 import { noopToken } from '../util/cancellation';
 import { Disposable } from '../util/dispose';
 import { isMarkdownFile, looksLikeMarkdownPath } from '../util/file';
 import { Limiter } from '../util/limiter';
 import { ResourceMap } from '../util/resourceMap';
 import { MdTableOfContentsWatcher } from '../util/tableOfContentsWatcher';
-import { MdWorkspaceContents, SkinnyTextDocument } from '../workspaceContents';
+import { IMdWorkspace } from '../workspace';
 import { InternalHref, LinkDefinitionSet, MdLink, MdLinkProvider, MdLinkSource } from './documentLinks';
 import { MdReferencesProvider, tryResolveLinkPath } from './references';
 
@@ -305,7 +306,7 @@ export class DiagnosticManager extends Disposable {
 	public readonly ready: Promise<void>;
 
 	constructor(
-		private readonly workspaceContents: MdWorkspaceContents,
+		private readonly workspace: IMdWorkspace,
 		private readonly computer: DiagnosticComputer,
 		private readonly configuration: DiagnosticConfiguration,
 		private readonly reporter: DiagnosticReporter,
@@ -322,17 +323,17 @@ export class DiagnosticManager extends Disposable {
 			this.rebuild();
 		}));
 
-		this._register(workspaceContents.onDidCreateMarkdownDocument(doc => {
+		this._register(workspace.onDidCreateMarkdownDocument(doc => {
 			this.triggerDiagnostics(doc.uri);
 			// Links in other files may have become valid
 			this.triggerForReferencingFiles(doc.uri);
 		}));
 
-		this._register(workspaceContents.onDidChangeMarkdownDocument(doc => {
+		this._register(workspace.onDidChangeMarkdownDocument(doc => {
 			this.triggerDiagnostics(doc.uri);
 		}));
 
-		this._register(workspaceContents.onDidDeleteMarkdownDocument(uri => {
+		this._register(workspace.onDidDeleteMarkdownDocument(uri => {
 			this.triggerForReferencingFiles(uri);
 		}));
 
@@ -352,7 +353,7 @@ export class DiagnosticManager extends Disposable {
 			}
 		}));
 
-		this.tableOfContentsWatcher = this._register(new MdTableOfContentsWatcher(workspaceContents, tocProvider, delay / 2));
+		this.tableOfContentsWatcher = this._register(new MdTableOfContentsWatcher(workspace, tocProvider, delay / 2));
 		this._register(this.tableOfContentsWatcher.onTocChanged(e => {
 			return this.triggerForReferencingFiles(e.uri);
 		}));
@@ -379,7 +380,7 @@ export class DiagnosticManager extends Disposable {
 		this.pendingDiagnostics.clear();
 	}
 
-	private async recomputeDiagnosticState(doc: SkinnyTextDocument, token: vscode.CancellationToken): Promise<{ diagnostics: readonly vscode.Diagnostic[]; links: readonly MdLink[]; config: DiagnosticOptions }> {
+	private async recomputeDiagnosticState(doc: ITextDocument, token: vscode.CancellationToken): Promise<{ diagnostics: readonly vscode.Diagnostic[]; links: readonly MdLink[]; config: DiagnosticOptions }> {
 		this.logger.verbose('DiagnosticManager', `recomputeDiagnosticState - ${doc.uri}`);
 
 		const config = this.configuration.getOptions(doc.uri);
@@ -394,7 +395,7 @@ export class DiagnosticManager extends Disposable {
 		this.pendingDiagnostics.clear();
 
 		await Promise.all(pending.map(async resource => {
-			const doc = await this.workspaceContents.getOrLoadMarkdownDocument(resource);
+			const doc = await this.workspace.getOrLoadMarkdownDocument(resource);
 			if (doc) {
 				await this.inFlightDiagnostics.trigger(doc.uri, async (token) => {
 					if (this.reporter.areDiagnosticsEnabled(doc.uri)) {
@@ -419,7 +420,7 @@ export class DiagnosticManager extends Disposable {
 			(async () => {
 				// TODO: This pulls in all md files in the workspace. Instead we only care about opened text documents.
 				// Need a new way to handle that.
-				const allDocs = await this.workspaceContents.getAllMarkdownDocuments();
+				const allDocs = await this.workspace.getAllMarkdownDocuments();
 				await Promise.all(Array.from(allDocs, doc => this.triggerDiagnostics(doc.uri)));
 			})()
 		);
@@ -475,12 +476,12 @@ class FileLinkMap {
 export class DiagnosticComputer {
 
 	constructor(
-		private readonly workspaceContents: MdWorkspaceContents,
+		private readonly workspace: IMdWorkspace,
 		private readonly linkProvider: MdLinkProvider,
 		private readonly tocProvider: MdTableOfContentsProvider,
 	) { }
 
-	public async getDiagnostics(doc: SkinnyTextDocument, options: DiagnosticOptions, token: vscode.CancellationToken): Promise<{ readonly diagnostics: vscode.Diagnostic[]; readonly links: readonly MdLink[] }> {
+	public async getDiagnostics(doc: ITextDocument, options: DiagnosticOptions, token: vscode.CancellationToken): Promise<{ readonly diagnostics: vscode.Diagnostic[]; readonly links: readonly MdLink[] }> {
 		const { links, definitions } = await this.linkProvider.getLinks(doc);
 		if (token.isCancellationRequested || !options.enabled) {
 			return { links, diagnostics: [] };
@@ -496,7 +497,7 @@ export class DiagnosticComputer {
 		};
 	}
 
-	private async validateFragmentLinks(doc: SkinnyTextDocument, options: DiagnosticOptions, links: readonly MdLink[], token: vscode.CancellationToken): Promise<vscode.Diagnostic[]> {
+	private async validateFragmentLinks(doc: ITextDocument, options: DiagnosticOptions, links: readonly MdLink[], token: vscode.CancellationToken): Promise<vscode.Diagnostic[]> {
 		const severity = toSeverity(options.validateFragmentLinks);
 		if (typeof severity === 'undefined') {
 			return [];
@@ -567,7 +568,7 @@ export class DiagnosticComputer {
 						return;
 					}
 
-					const resolvedHrefPath = await tryResolveLinkPath(path, this.workspaceContents);
+					const resolvedHrefPath = await tryResolveLinkPath(path, this.workspace);
 					if (!resolvedHrefPath) {
 						const msg = localize('invalidPathLink', 'File does not exist at path: {0}', path.fsPath);
 						for (const link of links) {
@@ -595,7 +596,7 @@ export class DiagnosticComputer {
 	}
 
 	private isMarkdownPath(resolvedHrefPath: vscode.Uri) {
-		return this.workspaceContents.hasMarkdownDocument(resolvedHrefPath) || looksLikeMarkdownPath(resolvedHrefPath);
+		return this.workspace.hasMarkdownDocument(resolvedHrefPath) || looksLikeMarkdownPath(resolvedHrefPath);
 	}
 
 	private isIgnoredLink(options: DiagnosticOptions, link: string): boolean {
@@ -652,7 +653,7 @@ class AddToIgnoreLinksQuickFixProvider implements vscode.CodeActionProvider {
 
 export function registerDiagnosticSupport(
 	selector: vscode.DocumentSelector,
-	workspaceContents: MdWorkspaceContents,
+	workspace: IMdWorkspace,
 	linkProvider: MdLinkProvider,
 	commandManager: CommandManager,
 	referenceProvider: MdReferencesProvider,
@@ -661,8 +662,8 @@ export function registerDiagnosticSupport(
 ): vscode.Disposable {
 	const configuration = new VSCodeDiagnosticConfiguration();
 	const manager = new DiagnosticManager(
-		workspaceContents,
-		new DiagnosticComputer(workspaceContents, linkProvider, tocProvider),
+		workspace,
+		new DiagnosticComputer(workspace, linkProvider, tocProvider),
 		configuration,
 		new DiagnosticCollectionReporter(),
 		referenceProvider,

extensions/markdown-language-features/src/languageFeatures/documentLinks.ts

@@ -7,14 +7,15 @@ import * as vscode from 'vscode';
 import * as nls from 'vscode-nls';
 import * as uri from 'vscode-uri';
 import { OpenDocumentLinkCommand } from '../commands/openDocumentLink';
+import { ILogger } from '../logging';
 import { IMdParser } from '../markdownEngine';
+import { ITextDocument } from '../types/textDocument';
 import { coalesce } from '../util/arrays';
 import { noopToken } from '../util/cancellation';
 import { Disposable } from '../util/dispose';
 import { getUriForLinkWithKnownExternalScheme, isOfScheme, Schemes } from '../util/schemes';
-import { MdWorkspaceContents, SkinnyTextDocument } from '../workspaceContents';
 import { MdDocumentInfoCache } from '../util/workspaceCache';
-import { ILogger } from '../logging';
+import { IMdWorkspace } from '../workspace';
 
 const localize = nls.loadMessageBundle();
 
@@ -38,7 +39,7 @@ export type LinkHref = ExternalHref | InternalHref | ReferenceHref;
 
 
 function parseLink(
-	document: SkinnyTextDocument,
+	document: ITextDocument,
 	link: string,
 ): ExternalHref | InternalHref | undefined {
 	const cleanLink = stripAngleBrackets(link);
@@ -91,7 +92,7 @@ function parseLink(
 	};
 }
 
-function getWorkspaceFolder(document: SkinnyTextDocument) {
+function getWorkspaceFolder(document: ITextDocument) {
 	return vscode.workspace.getWorkspaceFolder(document.uri)?.uri
 		|| vscode.workspace.workspaceFolders?.[0]?.uri;
 }
@@ -131,7 +132,7 @@ export interface MdLinkDefinition {
 export type MdLink = MdInlineLink | MdLinkDefinition;
 
 function extractDocumentLink(
-	document: SkinnyTextDocument,
+	document: ITextDocument,
 	pre: string,
 	rawLink: string,
 	matchIndex: number | undefined
@@ -170,7 +171,7 @@ function getFragmentRange(text: string, start: vscode.Position, end: vscode.Posi
 	return new vscode.Range(start.translate({ characterDelta: index + 1 }), end);
 }
 
-function getLinkSourceFragmentInfo(document: SkinnyTextDocument, link: string, linkStart: vscode.Position, linkEnd: vscode.Position): { fragmentRange: vscode.Range | undefined; pathText: string } {
+function getLinkSourceFragmentInfo(document: ITextDocument, link: string, linkStart: vscode.Position, linkEnd: vscode.Position): { fragmentRange: vscode.Range | undefined; pathText: string } {
 	const fragmentRange = getFragmentRange(link, linkStart, linkEnd);
 	return {
 		pathText: document.getText(new vscode.Range(linkStart, fragmentRange ? fragmentRange.start.translate(0, -1) : linkEnd)),
@@ -234,7 +235,7 @@ const definitionPattern = /^([\t ]*\[(?!\^)((?:\\\]|[^\]])+)\]:\s*)([^<]\S*|<[^>
 const inlineCodePattern = /(?:^|[^`])(`+)(?:.+?|.*?(?:(?:\r?\n).+?)*?)(?:\r?\n)?\1(?:$|[^`])/gm;
 
 class NoLinkRanges {
-	public static async compute(tokenizer: IMdParser, document: SkinnyTextDocument): Promise<NoLinkRanges> {
+	public static async compute(tokenizer: IMdParser, document: ITextDocument): Promise<NoLinkRanges> {
 		const tokens = await tokenizer.tokenize(document);
 		const multiline = tokens.filter(t => (t.type === 'code_block' || t.type === 'fence' || t.type === 'html_block') && !!t.map).map(t => t.map) as [number, number][];
 
@@ -274,7 +275,7 @@ export class MdLinkComputer {
 		private readonly tokenizer: IMdParser,
 	) { }
 
-	public async getAllLinks(document: SkinnyTextDocument, token: vscode.CancellationToken): Promise<MdLink[]> {
+	public async getAllLinks(document: ITextDocument, token: vscode.CancellationToken): Promise<MdLink[]> {
 		const noLinkRanges = await NoLinkRanges.compute(this.tokenizer, document);
 		if (token.isCancellationRequested) {
 			return [];
@@ -288,7 +289,7 @@ export class MdLinkComputer {
 		]);
 	}
 
-	private *getInlineLinks(document: SkinnyTextDocument, noLinkRanges: NoLinkRanges): Iterable<MdLink> {
+	private *getInlineLinks(document: ITextDocument, noLinkRanges: NoLinkRanges): Iterable<MdLink> {
 		const text = document.getText();
 		for (const match of text.matchAll(linkPattern)) {
 			const matchLinkData = extractDocumentLink(document, match[1], match[2], match.index);
@@ -306,7 +307,7 @@ export class MdLinkComputer {
 		}
 	}
 
-	private * getAutoLinks(document: SkinnyTextDocument, noLinkRanges: NoLinkRanges): Iterable<MdLink> {
+	private * getAutoLinks(document: ITextDocument, noLinkRanges: NoLinkRanges): Iterable<MdLink> {
 		const text = document.getText();
 
 		for (const match of text.matchAll(autoLinkPattern)) {
@@ -334,7 +335,7 @@ export class MdLinkComputer {
 		}
 	}
 
-	private *getReferenceLinks(document: SkinnyTextDocument, noLinkRanges: NoLinkRanges): Iterable<MdLink> {
+	private *getReferenceLinks(document: ITextDocument, noLinkRanges: NoLinkRanges): Iterable<MdLink> {
 		const text = document.getText();
 		for (const match of text.matchAll(referenceLinkPattern)) {
 			let linkStart: vscode.Position;
@@ -382,7 +383,7 @@ export class MdLinkComputer {
 		}
 	}
 
-	private *getLinkDefinitions(document: SkinnyTextDocument, noLinkRanges: NoLinkRanges): Iterable<MdLinkDefinition> {
+	private *getLinkDefinitions(document: ITextDocument, noLinkRanges: NoLinkRanges): Iterable<MdLinkDefinition> {
 		const text = document.getText();
 		for (const match of text.matchAll(definitionPattern)) {
 			const pre = match[1];
@@ -443,12 +444,12 @@ export class MdLinkProvider extends Disposable {
 
 	constructor(
 		tokenizer: IMdParser,
-		workspaceContents: MdWorkspaceContents,
+		workspace: IMdWorkspace,
 		logger: ILogger,
 	) {
 		super();
 		this.linkComputer = new MdLinkComputer(tokenizer);
-		this._linkCache = this._register(new MdDocumentInfoCache(workspaceContents, async doc => {
+		this._linkCache = this._register(new MdDocumentInfoCache(workspace, async doc => {
 			logger.verbose('LinkProvider', `compute - ${doc.uri}`);
 
 			const links = await this.linkComputer.getAllLinks(doc, noopToken);
@@ -459,7 +460,7 @@ export class MdLinkProvider extends Disposable {
 		}));
 	}
 
-	public async getLinks(document: SkinnyTextDocument): Promise<MdDocumentLinks> {
+	public async getLinks(document: ITextDocument): Promise<MdDocumentLinks> {
 		return this._linkCache.getForDocument(document);
 	}
 }
@@ -491,7 +492,7 @@ export class MdVsCodeLinkProvider implements vscode.DocumentLinkProvider {
 	) { }
 
 	public async provideDocumentLinks(
-		document: SkinnyTextDocument,
+		document: ITextDocument,
 		token: vscode.CancellationToken
 	): Promise<vscode.DocumentLink[]> {
 		const { links, definitions } = await this._linkProvider.getLinks(document);