import { joinLines } from './join_lines';
import { onEnter } from './on_enter';
import { parentModule } from './parent_module';
+import { syntaxTree } from './syntax_tree';
import * as expandMacro from './expand_macro';
import * as inlayHints from './inlay_hints';
import * as runnables from './runnables';
-import * as syntaxTree from './syntaxTree';
function collectGarbage(ctx: Ctx): Cmd {
return async () => {
+++ /dev/null
-import * as vscode from 'vscode';
-import { Range, TextDocumentIdentifier } from 'vscode-languageclient';
-
-import { Server } from '../server';
-
-export const syntaxTreeUri = vscode.Uri.parse('rust-analyzer://syntaxtree');
-
-export class SyntaxTreeContentProvider
- implements vscode.TextDocumentContentProvider {
- public eventEmitter = new vscode.EventEmitter<vscode.Uri>();
- public syntaxTree: string = 'Not available';
-
- public provideTextDocumentContent(
- uri: vscode.Uri,
- ): vscode.ProviderResult<string> {
- const editor = vscode.window.activeTextEditor;
- if (editor == null) {
- return '';
- }
-
- let range: Range | undefined;
-
- // When the range based query is enabled we take the range of the selection
- if (uri.query === 'range=true') {
- range = editor.selection.isEmpty
- ? undefined
- : Server.client.code2ProtocolConverter.asRange(
- editor.selection,
- );
- }
-
- const request: SyntaxTreeParams = {
- textDocument: { uri: editor.document.uri.toString() },
- range,
- };
- return Server.client.sendRequest<SyntaxTreeResult>(
- 'rust-analyzer/syntaxTree',
- request,
- );
- }
-
- get onDidChange(): vscode.Event<vscode.Uri> {
- return this.eventEmitter.event;
- }
-}
-
-interface SyntaxTreeParams {
- textDocument: TextDocumentIdentifier;
- range?: Range;
-}
-
-type SyntaxTreeResult = string;
-
-// Opens the virtual file that will show the syntax tree
-//
-// The contents of the file come from the `TextDocumentContentProvider`
-export function createHandle(provider: SyntaxTreeContentProvider) {
- return async () => {
- const editor = vscode.window.activeTextEditor;
- const rangeEnabled = !!(editor && !editor.selection.isEmpty);
-
- const uri = rangeEnabled
- ? vscode.Uri.parse(`${syntaxTreeUri.toString()}?range=true`)
- : syntaxTreeUri;
-
- const document = await vscode.workspace.openTextDocument(uri);
-
- provider.eventEmitter.fire(uri);
-
- return vscode.window.showTextDocument(
- document,
- vscode.ViewColumn.Two,
- true,
- );
- };
-}
--- /dev/null
+import * as vscode from 'vscode';
+import * as lc from 'vscode-languageclient';
+
+import { Ctx, Cmd } from '../ctx';
+
+// Opens the virtual file that will show the syntax tree
+//
+// The contents of the file come from the `TextDocumentContentProvider`
+export function syntaxTree(ctx: Ctx): Cmd {
+ const stcp = new SyntaxTreeContentProvider(ctx);
+
+ ctx.pushCleanup(
+ vscode.workspace.registerTextDocumentContentProvider(
+ 'rust-analyzer',
+ stcp,
+ ),
+ );
+
+ vscode.workspace.onDidChangeTextDocument(
+ (event: vscode.TextDocumentChangeEvent) => {
+ const doc = event.document;
+ if (doc.languageId !== 'rust') return;
+ afterLs(() => stcp.eventEmitter.fire(stcp.uri));
+ },
+ ctx.subscriptions,
+ );
+
+ vscode.window.onDidChangeActiveTextEditor(
+ (editor: vscode.TextEditor | undefined) => {
+ if (!editor || editor.document.languageId !== 'rust') return;
+ stcp.eventEmitter.fire(stcp.uri);
+ },
+ ctx.subscriptions,
+ );
+
+ return async () => {
+ const editor = vscode.window.activeTextEditor;
+ const rangeEnabled = !!(editor && !editor.selection.isEmpty);
+
+ const uri = rangeEnabled
+ ? vscode.Uri.parse(`${stcp.uri.toString()}?range=true`)
+ : stcp.uri;
+
+ const document = await vscode.workspace.openTextDocument(uri);
+
+ stcp.eventEmitter.fire(uri);
+
+ return vscode.window.showTextDocument(
+ document,
+ vscode.ViewColumn.Two,
+ true,
+ );
+ };
+}
+
+// We need to order this after LS updates, but there's no API for that.
+// Hence, good old setTimeout.
+function afterLs(f: () => any) {
+ setTimeout(f, 10);
+}
+
+interface SyntaxTreeParams {
+ textDocument: lc.TextDocumentIdentifier;
+ range?: lc.Range;
+}
+
+export class SyntaxTreeContentProvider
+ implements vscode.TextDocumentContentProvider {
+ ctx: Ctx;
+ uri = vscode.Uri.parse('rust-analyzer://syntaxtree');
+ eventEmitter = new vscode.EventEmitter<vscode.Uri>();
+ syntaxTree: string = 'Not available';
+
+ constructor(ctx: Ctx) {
+ this.ctx = ctx;
+ }
+
+ provideTextDocumentContent(uri: vscode.Uri): vscode.ProviderResult<string> {
+ const editor = vscode.window.activeTextEditor;
+ if (editor == null) return '';
+
+ let range: lc.Range | undefined;
+
+ // When the range based query is enabled we take the range of the selection
+ if (uri.query === 'range=true') {
+ range = editor.selection.isEmpty
+ ? undefined
+ : this.ctx.client.code2ProtocolConverter.asRange(
+ editor.selection,
+ );
+ }
+
+ const request: SyntaxTreeParams = {
+ textDocument: { uri: editor.document.uri.toString() },
+ range,
+ };
+ return this.ctx.client.sendRequest<string>(
+ 'rust-analyzer/syntaxTree',
+ request,
+ );
+ }
+
+ get onDidChange(): vscode.Event<vscode.Uri> {
+ return this.eventEmitter.event;
+ }
+}
}
}
+ get subscriptions(): { dispose(): any }[] {
+ return this.extCtx.subscriptions;
+ }
+
pushCleanup(d: { dispose(): any }) {
this.extCtx.subscriptions.push(d);
}
import { TextEditor } from 'vscode';
import { TextDocumentIdentifier } from 'vscode-languageclient';
-
-import {
- SyntaxTreeContentProvider,
- syntaxTreeUri,
-} from '../commands/syntaxTree';
import { Decoration } from '../highlighting';
import { Server } from '../server';
-export function makeHandler(syntaxTreeProvider: SyntaxTreeContentProvider) {
+export function makeHandler() {
return async function handle(editor: TextEditor | undefined) {
if (!editor || editor.document.languageId !== 'rust') {
return;
}
- syntaxTreeProvider.eventEmitter.fire(syntaxTreeUri);
-
if (!Server.config.highlightingOn) {
return;
}
+++ /dev/null
-import * as vscode from 'vscode';
-
-import {
- SyntaxTreeContentProvider,
- syntaxTreeUri,
-} from '../commands/syntaxTree';
-
-export function createHandler(syntaxTreeProvider: SyntaxTreeContentProvider) {
- return (event: vscode.TextDocumentChangeEvent) => {
- const doc = event.document;
- if (doc.languageId !== 'rust') {
- return;
- }
- afterLs(() => {
- syntaxTreeProvider.eventEmitter.fire(syntaxTreeUri);
- });
- };
-}
-
-// We need to order this after LS updates, but there's no API for that.
-// Hence, good old setTimeout.
-function afterLs(f: () => any) {
- setTimeout(f, 10);
-}
import * as changeActiveTextEditor from './change_active_text_editor';
-import * as changeTextDocument from './change_text_document';
-export { changeActiveTextEditor, changeTextDocument };
+export { changeActiveTextEditor };
import * as commands from './commands';
import { ExpandMacroContentProvider } from './commands/expand_macro';
import { HintsUpdater } from './commands/inlay_hints';
-import { SyntaxTreeContentProvider } from './commands/syntaxTree';
import { StatusDisplay } from './commands/watch_status';
import * as events from './events';
import * as notifications from './notifications';
ctx.registerCommand('matchingBrace', commands.matchingBrace);
ctx.registerCommand('joinLines', commands.joinLines);
ctx.registerCommand('parentModule', commands.parentModule);
+ ctx.registerCommand('syntaxTree', commands.syntaxTree);
function disposeOnDeactivation(disposable: vscode.Disposable) {
context.subscriptions.push(disposable);
disposeOnDeactivation(watchStatus);
// Notifications are events triggered by the language server
- const allNotifications: Iterable<[
- string,
- lc.GenericNotificationHandler,
- ]> = [
+ const allNotifications: [string, lc.GenericNotificationHandler][] = [
[
'rust-analyzer/publishDecorations',
notifications.publishDecorations.handle,
params => watchStatus.handleProgressNotification(params),
],
];
- const syntaxTreeContentProvider = new SyntaxTreeContentProvider();
const expandMacroContentProvider = new ExpandMacroContentProvider();
// The events below are plain old javascript events, triggered and handled by vscode
vscode.window.onDidChangeActiveTextEditor(
- events.changeActiveTextEditor.makeHandler(syntaxTreeContentProvider),
+ events.changeActiveTextEditor.makeHandler(),
);
- disposeOnDeactivation(
- vscode.workspace.registerTextDocumentContentProvider(
- 'rust-analyzer',
- syntaxTreeContentProvider,
- ),
- );
disposeOnDeactivation(
vscode.workspace.registerTextDocumentContentProvider(
'rust-analyzer',
),
);
- registerCommand(
- 'rust-analyzer.syntaxTree',
- commands.syntaxTree.createHandle(syntaxTreeContentProvider),
- );
registerCommand(
'rust-analyzer.expandMacro',
commands.expandMacro.createHandle(expandMacroContentProvider),
);
- vscode.workspace.onDidChangeTextDocument(
- events.changeTextDocument.createHandler(syntaxTreeContentProvider),
- null,
- context.subscriptions,
- );
-
const startServer = () => Server.start(allNotifications);
const reloadCommand = () => reloadServer(startServer);
projects / rust.git / commitdiff