Move matching brace to new Ctx

editors/code/src/commands/index.ts

@@ -1,11 +1,11 @@
 import { Ctx, Cmd } from '../ctx'
 
 import { analyzerStatus } from './analyzer_status';
+import { matchingBrace } from './matching_brace';
 import * as applySourceChange from './apply_source_change';
 import * as expandMacro from './expand_macro';
 import * as inlayHints from './inlay_hints';
 import * as joinLines from './join_lines';
-import * as matchingBrace from './matching_brace';
 import * as onEnter from './on_enter';
 import * as parentModule from './parent_module';
 import * as runnables from './runnables';

editors/code/src/commands/matching_brace.ts

@@ -1,30 +1,23 @@
 import * as vscode from 'vscode';
-
 import { Position, TextDocumentIdentifier } from 'vscode-languageclient';
-import { Server } from '../server';
+import { Ctx, Cmd } from '../ctx';
 
-interface FindMatchingBraceParams {
+export function matchingBrace(ctx: Ctx): Cmd {
-    textDocument: TextDocumentIdentifier;
+    return async () => {
-    offsets: Position[];
+        const editor = ctx.activeRustEditor;
-}
+        if (!editor) {
-
-export async function handle() {
-    const editor = vscode.window.activeTextEditor;
-    if (editor == null || editor.document.languageId !== 'rust') {
             return;
         }
         const request: FindMatchingBraceParams = {
             textDocument: { uri: editor.document.uri.toString() },
-        offsets: editor.selections.map(s => {
+            offsets: editor.selections.map(s => ctx.client.code2ProtocolConverter.asPosition(s.active)),
-            return Server.client.code2ProtocolConverter.asPosition(s.active);
-        }),
         };
-    const response = await Server.client.sendRequest<Position[]>(
+        const response = await ctx.client.sendRequest<Position[]>(
             'rust-analyzer/findMatchingBrace',
             request,
         );
         editor.selections = editor.selections.map((sel, idx) => {
-        const active = Server.client.protocol2CodeConverter.asPosition(
+            const active = ctx.client.protocol2CodeConverter.asPosition(
                 response[idx],
             );
             const anchor = sel.isEmpty ? active : sel.anchor;
@@ -32,3 +25,9 @@ export async function handle() {
         });
         editor.revealRange(editor.selection);
     }
+}
+
+interface FindMatchingBraceParams {
+    textDocument: TextDocumentIdentifier;
+    offsets: Position[];
+}

editors/code/src/ctx.ts

@@ -13,6 +13,13 @@ export class Ctx {
         return Server.client;
     }
 
+    get activeRustEditor(): vscode.TextEditor | undefined {
+        const editor = vscode.window.activeTextEditor;
+        return editor && editor.document.languageId === 'rust'
+            ? editor
+            : undefined;
+    }
+
     registerCommand(name: string, factory: (ctx: Ctx) => Cmd) {
         const fullName = `rust-analyzer.${name}`;
         const cmd = factory(this);

editors/code/src/main.ts

@@ -17,6 +17,7 @@ export async function activate(context: vscode.ExtensionContext) {
     ctx = new Ctx(context);
     ctx.registerCommand('analyzerStatus', commands.analyzerStatus);
     ctx.registerCommand('collectGarbage', commands.collectGarbage);
+    ctx.registerCommand('matchingBrace', commands.matchingBrace);
 
     function disposeOnDeactivation(disposable: vscode.Disposable) {
         context.subscriptions.push(disposable);
@@ -55,10 +56,6 @@ export async function activate(context: vscode.ExtensionContext) {
     }
 
     // Commands are requests from vscode to the language server
-    registerCommand(
-        'rust-analyzer.matchingBrace',
-        commands.matchingBrace.handle,
-    );
     registerCommand('rust-analyzer.joinLines', commands.joinLines.handle);
     registerCommand('rust-analyzer.parentModule', commands.parentModule.handle);
     registerCommand('rust-analyzer.run', commands.runnables.handle);