- "env": {

- "es6": true,

- "node": true

- "parser": "@typescript-eslint/parser",

- "parserOptions": {

- "project": "tsconfig.eslint.json",

- "tsconfigRootDir": __dirname,

- "sourceType": "module"

- "plugins": [

- "@typescript-eslint"

- ],

- "rules": {

- "camelcase": ["error"],

- "eqeqeq": ["error", "always", { "null": "ignore" }],

- "multiline": {

- "delimiter": "semi",

- "requireLast": true

- "singleline": {

- "delimiter": "semi",

- "requireLast": false

- }

- }

- ],

- "@typescript-eslint/semi": [

- "error",

- "always"

- "@typescript-eslint/no-floating-promises": "error"

- }

- "blockComment": [ "/*", "*/" ]

- ["{", "}"],

- ["[", "]"],

- ["(", ")"]

- ],

- "version": "0.4.0-dev",

- "version": "0.4.0-dev",

- "typescript-formatter": "^7.2.2",

- "node_modules/commandpost": {

- "version": "1.4.0",

- "resolved": "https://registry.npmjs.org/commandpost/-/commandpost-1.4.0.tgz",

- "integrity": "sha512-aE2Y4MTFJ870NuB/+2z1cXBhSBBzRydVVjzhFC4gtenEhpnj15yu0qptWGJsO9YGrcPZ3ezX8AWb1VA391MKpQ==",

- "dev": true

- },

- "node_modules/editorconfig": {

- "version": "0.15.3",

- "resolved": "https://registry.npmjs.org/editorconfig/-/editorconfig-0.15.3.tgz",

- "integrity": "sha512-M9wIMFx96vq0R4F+gRpY3o2exzb8hEj/n9S8unZtHSvYjibBp/iMufSzvmOcV/laG0ZtuTVGtiJggPOSW2r93g==",

- "dev": true,

- "dependencies": {

- "commander": "^2.19.0",

- "lru-cache": "^4.1.5",

- "semver": "^5.6.0",

- "sigmund": "^1.0.1"

- },

- "bin": {

- "editorconfig": "bin/editorconfig"

- }

- },

- "node_modules/editorconfig/node_modules/commander": {

- "version": "2.20.3",

- "resolved": "https://registry.npmjs.org/commander/-/commander-2.20.3.tgz",

- "integrity": "sha512-GpVkmM8vF2vQUkj2LvZmD35JxeJOLCwJ9cUkugyk2nuhbv3+mJvpLYYt+0+USMxE+oj+ey/lJEnhZw75x/OMcQ==",

- "dev": true

- },

- "node_modules/editorconfig/node_modules/lru-cache": {

- "version": "4.1.5",

- "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-4.1.5.tgz",

- "integrity": "sha512-sWZlbEP2OsHNkXrMl5GYk/jKk70MBng6UU4YI/qGDYbgf6YbP4EvmqISbXCoJiRKs+1bSpFHVgQxvJ17F2li5g==",

- "dev": true,

- "dependencies": {

- "pseudomap": "^1.0.2",

- "yallist": "^2.1.2"

- }

- },

- "node_modules/editorconfig/node_modules/semver": {

- "version": "5.7.1",

- "resolved": "https://registry.npmjs.org/semver/-/semver-5.7.1.tgz",

- "integrity": "sha512-sauaDf/PZdVgrLTNYHRtpXa1iRiKcaebiKQ1BJdpQlWH2lCvexQdX55snPFyK7QzpudqbCI0qXFfOasHdyNDGQ==",

- "dev": true,

- "bin": {

- "semver": "bin/semver"

- }

- },

- "node_modules/editorconfig/node_modules/yallist": {

- "version": "2.1.2",

- "resolved": "https://registry.npmjs.org/yallist/-/yallist-2.1.2.tgz",

- "integrity": "sha1-HBH5IY8HYImkfdUS+TxmmaaoHVI=",

- "dev": true

- },

- "node_modules/pseudomap": {

- "version": "1.0.2",

- "resolved": "https://registry.npmjs.org/pseudomap/-/pseudomap-1.0.2.tgz",

- "integrity": "sha1-8FKijacOYYkX7wqKw0wa5aaChrM=",

- "dev": true

- },

- "node_modules/sigmund": {

- "version": "1.0.1",

- "resolved": "https://registry.npmjs.org/sigmund/-/sigmund-1.0.1.tgz",

- "integrity": "sha1-P/IfGYytIXX587eBhT/ZTQ0ZtZA=",

- "dev": true

- },

- "node_modules/typescript-formatter": {

- "version": "7.2.2",

- "resolved": "https://registry.npmjs.org/typescript-formatter/-/typescript-formatter-7.2.2.tgz",

- "integrity": "sha512-V7vfI9XArVhriOTYHPzMU2WUnm5IMdu9X/CPxs8mIMGxmTBFpDABlbkBka64PZJ9/xgQeRpK8KzzAG4MPzxBDQ==",

- "dev": true,

- "dependencies": {

- "commandpost": "^1.0.0",

- "editorconfig": "^0.15.0"

- },

- "bin": {

- "tsfmt": "bin/tsfmt"

- },

- "engines": {

- "node": ">= 4.2.0"

- },

- "peerDependencies": {

- "typescript": "^2.1.6 || >=2.7.0-dev || >=2.8.0-dev || >=2.9.0-dev || >=3.0.0-dev"

- }

- },

- "commandpost": {

- "version": "1.4.0",

- "resolved": "https://registry.npmjs.org/commandpost/-/commandpost-1.4.0.tgz",

- "integrity": "sha512-aE2Y4MTFJ870NuB/+2z1cXBhSBBzRydVVjzhFC4gtenEhpnj15yu0qptWGJsO9YGrcPZ3ezX8AWb1VA391MKpQ==",

- "dev": true

- },

- "editorconfig": {

- "version": "0.15.3",

- "resolved": "https://registry.npmjs.org/editorconfig/-/editorconfig-0.15.3.tgz",

- "integrity": "sha512-M9wIMFx96vq0R4F+gRpY3o2exzb8hEj/n9S8unZtHSvYjibBp/iMufSzvmOcV/laG0ZtuTVGtiJggPOSW2r93g==",

- "dev": true,

- "requires": {

- "commander": "^2.19.0",

- "lru-cache": "^4.1.5",

- "semver": "^5.6.0",

- "sigmund": "^1.0.1"

- },

- "dependencies": {

- "commander": {

- "version": "2.20.3",

- "resolved": "https://registry.npmjs.org/commander/-/commander-2.20.3.tgz",

- "integrity": "sha512-GpVkmM8vF2vQUkj2LvZmD35JxeJOLCwJ9cUkugyk2nuhbv3+mJvpLYYt+0+USMxE+oj+ey/lJEnhZw75x/OMcQ==",

- "dev": true

- },

- "lru-cache": {

- "version": "4.1.5",

- "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-4.1.5.tgz",

- "integrity": "sha512-sWZlbEP2OsHNkXrMl5GYk/jKk70MBng6UU4YI/qGDYbgf6YbP4EvmqISbXCoJiRKs+1bSpFHVgQxvJ17F2li5g==",

- "dev": true,

- "requires": {

- "pseudomap": "^1.0.2",

- "yallist": "^2.1.2"

- }

- },

- "semver": {

- "version": "5.7.1",

- "resolved": "https://registry.npmjs.org/semver/-/semver-5.7.1.tgz",

- "integrity": "sha512-sauaDf/PZdVgrLTNYHRtpXa1iRiKcaebiKQ1BJdpQlWH2lCvexQdX55snPFyK7QzpudqbCI0qXFfOasHdyNDGQ==",

- "dev": true

- },

- "yallist": {

- "version": "2.1.2",

- "resolved": "https://registry.npmjs.org/yallist/-/yallist-2.1.2.tgz",

- "integrity": "sha1-HBH5IY8HYImkfdUS+TxmmaaoHVI=",

- "dev": true

- }

- }

- },

- "pseudomap": {

- "version": "1.0.2",

- "resolved": "https://registry.npmjs.org/pseudomap/-/pseudomap-1.0.2.tgz",

- "integrity": "sha1-8FKijacOYYkX7wqKw0wa5aaChrM=",

- "dev": true

- },

- "sigmund": {

- "version": "1.0.1",

- "resolved": "https://registry.npmjs.org/sigmund/-/sigmund-1.0.1.tgz",

- "integrity": "sha1-P/IfGYytIXX587eBhT/ZTQ0ZtZA=",

- "dev": true

- },

- "typescript-formatter": {

- "version": "7.2.2",

- "resolved": "https://registry.npmjs.org/typescript-formatter/-/typescript-formatter-7.2.2.tgz",

- "integrity": "sha512-V7vfI9XArVhriOTYHPzMU2WUnm5IMdu9X/CPxs8mIMGxmTBFpDABlbkBka64PZJ9/xgQeRpK8KzzAG4MPzxBDQ==",

- "dev": true,

- "requires": {

- "commandpost": "^1.0.0",

- "editorconfig": "^0.15.0"

- }

- },

- "lint": "tsfmt --verify && eslint -c .eslintrc.js --ext ts ./src ./tests",

- "fix": " tsfmt -r && eslint -c .eslintrc.js --ext ts ./src ./tests --fix",

- "typescript-formatter": "^7.2.2",

- "fileTypes": [

- "rast"

- ]

-import * as vscode from 'vscode';

-import { Ctx, Disposable } from './ctx';

-import { RustEditor, isRustEditor } from './util';

- borderColor: new vscode.ThemeColor('rust_analyzer.syntaxTreeBorder'),

- ctx.pushCleanup(vscode.languages.registerHoverProvider({ scheme: 'rust-analyzer' }, this));

- vscode.workspace.onDidCloseTextDocument(this.onDidCloseTextDocument, this, ctx.subscriptions);

- vscode.workspace.onDidChangeTextDocument(this.onDidChangeTextDocument, this, ctx.subscriptions);

- vscode.window.onDidChangeVisibleTextEditors(this.onDidChangeVisibleTextEditors, this, ctx.subscriptions);

- if (this.rustEditor && event.document.uri.toString() === this.rustEditor.document.uri.toString()) {

- return vscode.window.visibleTextEditors.find(it => it.document.uri.scheme === 'rust-analyzer');

- provideDefinition(doc: vscode.TextDocument, pos: vscode.Position): vscode.ProviderResult<vscode.DefinitionLink[]> {

- if (!this.rustEditor || doc.uri.toString() !== this.rustEditor.document.uri.toString()) return;

- const rust2AstRanges = this.rust2Ast.get()?.find(([rustRange, _]) => rustRange.contains(pos));

- return [{

- targetRange: astFileRange,

- targetUri: astEditor.document.uri,

- originSelectionRange: rustFileRange,

- targetSelectionRange: astFileRange,

- }];

- provideHover(doc: vscode.TextDocument, hoverPosition: vscode.Position): vscode.ProviderResult<vscode.Hover> {

- private parseRustTextRange(doc: vscode.TextDocument, astLine: string): undefined | vscode.Range {

- const [begin, end] = parsedRange

- .slice(1)

- .map(off => this.positionAt(doc, +off));

- constructor(private readonly compute: () => undefined | T) { }

-import * as lc from 'vscode-languageclient/node';

-import * as vscode from 'vscode';

-import * as ra from '../src/lsp_ext';

-import * as Is from 'vscode-languageclient/lib/common/utils/is';

-import { assert } from './util';

-import { WorkspaceEdit } from 'vscode';

-import { Workspace } from './ctx';

-import { updateConfig } from './config';

-import { substituteVariablesInEnv } from './config';

- return `[${cmd.title}](command:${cmd.command}?${encodeURIComponent(JSON.stringify(cmd.arguments))} '${cmd.tooltip}')`;

- const text = actions.map(group =>

- (group.title ? (group.title + " ") : "") + group.commands.map(renderCommand).join(' | ')

- ).join('___');

-export async function createClient(serverPath: string, workspace: Workspace, extraEnv: Env): Promise<lc.LanguageClient> {

- const newEnv = substituteVariablesInEnv(Object.assign(

- {}, process.env, extraEnv

- ));

- 'Rust Analyzer Language Server Trace',

- await updateConfig(initializationOptions).catch(err => {

- initializationOptions = { "detachedFiles": workspace.files.map(file => file.uri.fsPath), ...initializationOptions };

- documentSelector: [{ scheme: 'file', language: 'rust' }],

- async provideHover(document: vscode.TextDocument, position: vscode.Position, token: vscode.CancellationToken, _next: lc.ProvideHoverSignature) {

- const positionOrRange = editor?.selection?.contains(position) ? client.code2ProtocolConverter.asRange(editor.selection) : client.code2ProtocolConverter.asPosition(position);

- return client.sendRequest(ra.hover, {

- textDocument: client.code2ProtocolConverter.asTextDocumentIdentifier(document),

- position: positionOrRange

- }, token).then(

- (result) => {

- const hover =

- client.protocol2CodeConverter.asHover(result);

- if (hover) {

- const actions = (<any>result).actions;

- if (actions) {

- hover.contents.push(renderHoverActions(actions));

- return hover;

- },

- (error) => {

- client.handleFailedRequest(

- lc.HoverRequest.type,

- token,

- error,

- null

- );

- return Promise.resolve(null);

- }

- );

- async provideCodeActions(document: vscode.TextDocument, range: vscode.Range, context: vscode.CodeActionContext, token: vscode.CancellationToken, _next: lc.ProvideCodeActionsSignature) {

- context: await client.code2ProtocolConverter.asCodeActionContext(context, token)

- return client.sendRequest(lc.CodeActionRequest.type, params, token).then(async (values) => {

- if (values === null) return undefined;

- const result: (vscode.CodeAction | vscode.Command)[] = [];

- const groups = new Map<string, { index: number; items: vscode.CodeAction[] }>();

- for (const item of values) {

- // In our case we expect to get code edits only from diagnostics

- if (lc.CodeAction.is(item)) {

- assert(!item.command, "We don't expect to receive commands in CodeActions");

- const action = await client.protocol2CodeConverter.asCodeAction(item, token);

- result.push(action);

- continue;

- }

- assert(isCodeActionWithoutEditsAndCommands(item), "We don't expect edits or commands here");

- const kind = client.protocol2CodeConverter.asCodeActionKind((item as any).kind);

- const action = new vscode.CodeAction(item.title, kind);

- const group = (item as any).group;

- action.command = {

- command: "rust-analyzer.resolveCodeAction",

- title: item.title,

- arguments: [item],

- };

-

- // Set a dummy edit, so that VS Code doesn't try to resolve this.

- action.edit = new WorkspaceEdit();

-

- if (group) {

- let entry = groups.get(group);

- if (!entry) {

- entry = { index: result.length, items: [] };

- groups.set(group, entry);

- entry.items.push(action);

- } else {

- result.push(action);

- }

- }

- for (const [group, { index, items }] of groups) {

- if (items.length === 1) {

- result[index] = items[0];

- } else {

- const action = new vscode.CodeAction(group);

- action.kind = items[0].kind;

- command: "rust-analyzer.applyActionGroup",

- title: "",

- arguments: [items.map((item) => {

- return { label: item.title, arguments: item.command!.arguments![0] };

- })],

- result[index] = action;

- }

- return result;

- },

- }

-

- }

- 'rust-analyzer',

- 'Rust Analyzer Language Server',

- clientOptions,

- ]

- initialize(_capabilities: lc.ServerCapabilities<any>, _documentSelector: lc.DocumentSelector | undefined): void {

- }

- dispose(): void {

- }

- return candidate && Is.string(candidate.title) &&

- (candidate.diagnostics === void 0 || Is.typedArray(candidate.diagnostics, lc.Diagnostic.is)) &&

- (candidate.edit === void 0 && candidate.command === void 0);

-import * as vscode from 'vscode';

-import * as lc from 'vscode-languageclient';

-import * as ra from './lsp_ext';

-import * as path from 'path';

-

-import { Ctx, Cmd } from './ctx';

-import { applySnippetWorkspaceEdit, applySnippetTextEdits } from './snippets';

-import { spawnSync } from 'child_process';

-import { RunnableQuickPick, selectRunnable, createTask, createArgs } from './run';

-import { AstInspector } from './ast_inspector';

-import { isRustDocument, isCargoTomlDocument, sleep, isRustEditor } from './util';

-import { startDebugSession, makeDebugConfig } from './debug';

-import { LanguageClient } from 'vscode-languageclient/node';

-

-export * from './ast_inspector';

-export * from './run';

- const tdcp = new class implements vscode.TextDocumentContentProvider {

- readonly uri = vscode.Uri.parse('rust-analyzer-status://status');

- if (!vscode.window.activeTextEditor) return '';

- params.textDocument = ctx.client.code2ProtocolConverter.asTextDocumentIdentifier(doc);

- }();

- vscode.workspace.registerTextDocumentContentProvider(

- 'rust-analyzer-status',

- tdcp,

- ),

- void await vscode.window.showTextDocument(document, {

- preserveFocus: true

- });

- const tdcp = new class implements vscode.TextDocumentContentProvider {

- readonly uri = vscode.Uri.parse('rust-analyzer-memory://memory');

- if (!vscode.window.activeTextEditor) return '';

- return 'Per-query memory usage:\n' + mem + '\n(note: database has been cleared)';

- }();

- vscode.workspace.registerTextDocumentContentProvider(

- 'rust-analyzer-memory',

- tdcp,

- ),

- textDocument: ctx.client.code2ProtocolConverter.asTextDocumentIdentifier(editor.document),

- positions: editor.selections.map(s =>

- client.code2ProtocolConverter.asPosition(s.active),

- const active = client.protocol2CodeConverter.asPosition(

- response[idx],

- );

- textDocument: ctx.client.code2ProtocolConverter.asTextDocumentIdentifier(editor.document),

- textDocument: ctx.client.code2ProtocolConverter.asTextDocumentIdentifier(editor.document),

- direction

- const lcEdits = await client.sendRequest(ra.onEnter, {

- textDocument: ctx.client.code2ProtocolConverter.asTextDocumentIdentifier(editor.document),

- position: client.code2ProtocolConverter.asPosition(

- editor.selection.active,

- ),

- }).catch((_error: any) => {

- // client.handleFailedRequest(OnEnterRequest.type, error, null);

- return null;

- });

- await vscode.commands.executeCommand('default:type', { text: '\n' });

- textDocument: ctx.client.code2ProtocolConverter.asTextDocumentIdentifier(editor.document),

- position: client.code2ProtocolConverter.asPosition(

- editor.selection.active,

- await showReferencesImpl(client, uri, position, locations.map(loc => lc.Location.create(loc.targetUri, loc.targetRange)));

- textDocument: ctx.client.code2ProtocolConverter.asTextDocumentIdentifier(editor.document),

- const textDocument = ctx.client.code2ProtocolConverter.asTextDocumentIdentifier(editor.document);

- query: x, parseOnly: true, textDocument, position, selections,

- }

- await vscode.window.withProgress({

- location: vscode.ProgressLocation.Notification,

- title: "Structured search replace in progress...",

- cancellable: false,

- }, async (_progress, token) => {

- const edit = await client.sendRequest(ra.ssr, {

- query: request, parseOnly: false, textDocument, position, selections,

- });

-

- await vscode.workspace.applyEdit(await client.protocol2CodeConverter.asWorkspaceEdit(edit, token));

- });

- void vscode.window.showInformationMessage(

- `rust-analyzer version: ${versionString}`

- );

- const config = vscode.workspace.getConfiguration("editor.inlayHints", { languageId: "rust" });

- await config.update('enabled', value, vscode.ConfigurationTarget.Global);

- const tdcp = new class implements vscode.TextDocumentContentProvider {

- readonly uri = vscode.Uri.parse('rust-analyzer://syntaxtree/tree.rast');

- vscode.workspace.onDidChangeTextDocument(this.onDidChangeTextDocument, this, ctx.subscriptions);

- vscode.window.onDidChangeActiveTextEditor(this.onDidChangeActiveTextEditor, this, ctx.subscriptions);

- provideTextDocumentContent(uri: vscode.Uri, ct: vscode.CancellationToken): vscode.ProviderResult<string> {

- if (!rustEditor) return '';

- const range = uri.query === 'range=true' && !rustEditor.selection.isEmpty

- ? ctx.client.code2ProtocolConverter.asRange(rustEditor.selection)

- : null;

- const params = { textDocument: { uri: rustEditor.document.uri.toString() }, range, };

- };

- ctx.pushCleanup(vscode.workspace.registerTextDocumentContentProvider('rust-analyzer', tdcp));

- ctx.pushCleanup(vscode.languages.setLanguageConfiguration("ra_syntax_tree", {

- brackets: [["[", ")"]],

- }));

- const uri = rangeEnabled

- ? vscode.Uri.parse(`${tdcp.uri.toString()}?range=true`)

- : tdcp.uri;

- void await vscode.window.showTextDocument(document, {

- preserveFocus: true

- });

- const tdcp = new class implements vscode.TextDocumentContentProvider {

- readonly uri = vscode.Uri.parse('rust-analyzer://viewHir/hir.txt');

- vscode.workspace.onDidChangeTextDocument(this.onDidChangeTextDocument, this, ctx.subscriptions);

- vscode.window.onDidChangeActiveTextEditor(this.onDidChangeActiveTextEditor, this, ctx.subscriptions);

- provideTextDocumentContent(_uri: vscode.Uri, ct: vscode.CancellationToken): vscode.ProviderResult<string> {

- if (!rustEditor || !client) return '';

- textDocument: client.code2ProtocolConverter.asTextDocumentIdentifier(rustEditor.document),

- position: client.code2ProtocolConverter.asPosition(

- rustEditor.selection.active,

- };

- ctx.pushCleanup(vscode.workspace.registerTextDocumentContentProvider('rust-analyzer', tdcp));

- void await vscode.window.showTextDocument(document, {

- preserveFocus: true

- });

- const tdcp = new class implements vscode.TextDocumentContentProvider {

- readonly uri = vscode.Uri.parse('rust-analyzer://viewFileText/file.rs');

- vscode.workspace.onDidChangeTextDocument(this.onDidChangeTextDocument, this, ctx.subscriptions);

- vscode.window.onDidChangeActiveTextEditor(this.onDidChangeActiveTextEditor, this, ctx.subscriptions);

- provideTextDocumentContent(_uri: vscode.Uri, ct: vscode.CancellationToken): vscode.ProviderResult<string> {

- if (!rustEditor || !client) return '';

- const params = client.code2ProtocolConverter.asTextDocumentIdentifier(rustEditor.document);

- };

- ctx.pushCleanup(vscode.workspace.registerTextDocumentContentProvider('rust-analyzer', tdcp));

- void await vscode.window.showTextDocument(document, {

- preserveFocus: true

- });

- const tdcp = new class implements vscode.TextDocumentContentProvider {

- readonly uri = vscode.Uri.parse('rust-analyzer://viewItemTree/itemtree.rs');

- vscode.workspace.onDidChangeTextDocument(this.onDidChangeTextDocument, this, ctx.subscriptions);

- vscode.window.onDidChangeActiveTextEditor(this.onDidChangeActiveTextEditor, this, ctx.subscriptions);

- provideTextDocumentContent(_uri: vscode.Uri, ct: vscode.CancellationToken): vscode.ProviderResult<string> {

- if (!rustEditor || !client) return '';

- textDocument: client.code2ProtocolConverter.asTextDocumentIdentifier(rustEditor.document),

- };

- ctx.pushCleanup(vscode.workspace.registerTextDocumentContentProvider('rust-analyzer', tdcp));

- void await vscode.window.showTextDocument(document, {

- preserveFocus: true

- });

- const panel = vscode.window.createWebviewPanel("rust-analyzer.crate-graph", "rust-analyzer crate graph", vscode.ViewColumn.Two, {

- enableScripts: true,

- retainContextWhenHidden: true,

- localResourceRoots: [nodeModulesPath]

- });

- result += '// ' + '='.repeat(result.length - 3);

- result += '\n\n';

- const tdcp = new class implements vscode.TextDocumentContentProvider {

- uri = vscode.Uri.parse('rust-analyzer://expandMacro/[EXPANSION].rs');

- if (!editor || !client) return '';

- textDocument: ctx.client.code2ProtocolConverter.asTextDocumentIdentifier(editor.document),

- if (expanded == null) return 'Not available';

- }();

- ctx.pushCleanup(

- vscode.workspace.registerTextDocumentContentProvider(

- 'rust-analyzer',

- tdcp,

- ),

- );

- return vscode.window.showTextDocument(

- document,

- vscode.ViewColumn.Two,

- true,

- );

-async function showReferencesImpl(client: LanguageClient, uri: string, position: lc.Position, locations: lc.Location[]) {

- 'editor.action.showReferences',

- locations.map(client.protocol2CodeConverter.asLocation),

- 'rust-analyzer.resolveCodeAction',

- selectedAction.arguments,

-

- };

-

- const lcFileSystemEdit = { ...itemEdit, documentChanges: itemEdit.documentChanges?.filter(change => "kind" in change) };

- const fileSystemEdit = await client.protocol2CodeConverter.asWorkspaceEdit(lcFileSystemEdit);

- item.detail = 'rerun';

- await vscode.window.withProgress({

- location: vscode.ProgressLocation.Notification,

- title: "Looking for tests...",

- cancellable: false,

- }, async (_progress, _token) => {

- const uri = editor.document.uri.toString();

- const position = client.code2ProtocolConverter.asPosition(

- editor.selection.active,

- );

-

- const tests = await client.sendRequest(ra.relatedTests, {

- textDocument: { uri: uri },

- position: position,

- });

- const locations: lc.Location[] = tests.map(it =>

- lc.Location.create(it.runnable.location!.targetUri, it.runnable.location!.targetSelectionRange));

-

- await showReferencesImpl(client, uri, position, locations);

- });

-

- item.detail = 'restart';

-import path = require('path');

-import * as vscode from 'vscode';

-import { Env } from './client';

-export type RunnableEnvCfg = undefined | Record<string, string> | { mask?: string; env: Record<string, string> }[];

- ]

- .map(opt => `${this.rootSection}.${opt}`);

- vscode.workspace.onDidChangeConfiguration(this.onDidChangeConfiguration, this, ctx.subscriptions);

- const requiresReloadOpt = this.requiresReloadOpts.find(

- opt => event.affectsConfiguration(opt)

- get serverExtraEnv() { return this.get<Env | null>("server.extraEnv") ?? {}; }

- get traceExtension() { return this.get<boolean>("trace.extension"); }

- const { ["/rustc/<id>"]: _, ...trimmed } = this.get<Record<string, string>>("debug.sourceFileMap");

- sourceFileMap: sourceFileMap

- ["assist.allowMergingIntoGlobImports", "imports.merge.glob",],

- ["assist.exprFillDefault", "assist.expressionFillDefault",],

- ["assist.importEnforceGranularity", "imports.granularity.enforce",],

- ["assist.importGranularity", "imports.granularity.group",],

- ["assist.importMergeBehavior", "imports.granularity.group",],

- ["assist.importMergeBehaviour", "imports.granularity.group",],

- ["assist.importGroup", "imports.group.enable",],

- ["assist.importPrefix", "imports.prefix",],

- ["primeCaches.enable", "cachePriming.enable",],

- ["cache.warmup", "cachePriming.enable",],

- ["cargo.loadOutDirsFromCheck", "cargo.buildScripts.enable",],

- ["cargo.runBuildScripts", "cargo.buildScripts.enable",],

- ["cargo.runBuildScriptsCommand", "cargo.buildScripts.overrideCommand",],

- ["cargo.useRustcWrapperForBuildScripts", "cargo.buildScripts.useRustcWrapper",],

- ["completion.snippets", "completion.snippets.custom",],

- ["diagnostics.enableExperimental", "diagnostics.experimental.enable",],

- ["experimental.procAttrMacros", "procMacro.attributes.enable",],

- ["highlighting.strings", "semanticHighlighting.strings.enable",],

- ["highlightRelated.breakPoints", "highlightRelated.breakPoints.enable",],

- ["highlightRelated.exitPoints", "highlightRelated.exitPoints.enable",],

- ["highlightRelated.yieldPoints", "highlightRelated.yieldPoints.enable",],

- ["highlightRelated.references", "highlightRelated.references.enable",],

- ["hover.documentation", "hover.documentation.enable",],

- ["hover.linksInHover", "hover.links.enable",],

- ["hoverActions.linksInHover", "hover.links.enable",],

- ["hoverActions.debug", "hover.actions.debug.enable",],

- ["hoverActions.enable", "hover.actions.enable.enable",],

- ["hoverActions.gotoTypeDef", "hover.actions.gotoTypeDef.enable",],

- ["hoverActions.implementations", "hover.actions.implementations.enable",],

- ["hoverActions.references", "hover.actions.references.enable",],

- ["hoverActions.run", "hover.actions.run.enable",],

- ["inlayHints.chainingHints", "inlayHints.chainingHints.enable",],

- ["inlayHints.closureReturnTypeHints", "inlayHints.closureReturnTypeHints.enable",],

- ["inlayHints.hideNamedConstructorHints", "inlayHints.typeHints.hideNamedConstructor",],

- ["inlayHints.parameterHints", "inlayHints.parameterHints.enable",],

- ["inlayHints.reborrowHints", "inlayHints.reborrowHints.enable",],

- ["inlayHints.typeHints", "inlayHints.typeHints.enable",],

- ["lruCapacity", "lru.capacity",],

- ["runnables.cargoExtraArgs", "runnables.extraArgs",],

- ["runnables.overrideCargo", "runnables.command",],

- ["rustcSource", "rustc.source",],

- ["rustfmt.enableRangeFormatting", "rustfmt.rangeFormatting.enable"]

- { val: inspect.globalValue, langVal: inspect.globalLanguageValue, target: vscode.ConfigurationTarget.Global },

- { val: inspect.workspaceFolderValue, langVal: inspect.workspaceFolderLanguageValue, target: vscode.ConfigurationTarget.WorkspaceFolder },

- { val: inspect.workspaceValue, langVal: inspect.workspaceLanguageValue, target: vscode.ConfigurationTarget.Workspace }

- return val !== undefined && !(typeof val === "object" && val !== null && (val.hasOwnProperty("enable") || val.hasOwnProperty("custom")));

- const definedEnvKeys = new Set(Object.keys(env).map(key => `env:${key}`));

- const envWithDeps = Object.fromEntries(Object.entries(env).map(([key, value]) => {

- const deps = new Set<string>();

- const depRe = new RegExp(/\${(?<depName>.+?)}/g);

- let match = undefined;

- while ((match = depRe.exec(value))) {

- const depName = match.groups!.depName;

- deps.add(depName);

- // `depName` at this point can have a form of `expression` or

- // `prefix:expression`

- if (!definedEnvKeys.has(depName)) {

- missingDeps.add(depName);

- }

- return [`env:${key}`, { deps: [...deps], value }];

- }));

- if (prefix === 'env') {

- value: process.env[envName] ?? '',

- deps: []

- value: '${' + dep + '}',

- deps: []

- deps: []

- if (envWithDeps[key].deps.every(dep => resolved.has(dep))) {

- /\${(?<depName>.+?)}/g, (_wholeMatch, depName) => {

- });

- return '';

- const workspaceFolder = computeVscodeVar('workspaceFolder');

- return '';

- pathSeparator: () => path.sep

- return '${' + varName + '}';

-import * as vscode from 'vscode';

-import * as lc from 'vscode-languageclient/node';

-import * as ra from './lsp_ext';

-import { Config } from './config';

-import { createClient } from './client';

-import { isRustEditor, RustEditor } from './util';

-import { ServerStatusParams } from './lsp_ext';

- {

- kind: 'Workspace Folder';

- }

- kind: 'Detached Files';

- files: vscode.TextDocument[];

- };

- readonly statusBar: vscode.StatusBarItem,

- ) {

-

- }

- workspace: Workspace,

- return editor && isRustEditor(editor)

- ? editor

- : undefined;

-import * as vscode from 'vscode';

-import * as path from 'path';

-import * as ra from './lsp_ext';

-import { Cargo, getRustcId, getSysroot } from './toolchain';

-type DebugConfigProvider = (config: ra.Runnable, executable: string, env: Record<string, string>, sourceFileMap?: Record<string, string>) => vscode.DebugConfiguration;

- const index = configurations.findIndex(c => c.name === debugConfig.name);

- const answer = await vscode.window.showErrorMessage(`Launch configuration '${debugConfig.name}' already exists!`, 'Cancel', 'Update');

- const index = configurations.findIndex(c => c.name === runnable.label);

-async function getDebugConfiguration(ctx: Ctx, runnable: ra.Runnable): Promise<vscode.DebugConfiguration | undefined> {

- "ms-vscode.cpptools": getCppvsDebugConfig

- await vscode.window.showErrorMessage(`Install [CodeLLDB](https://marketplace.visualstudio.com/items?itemName=vadimcn.vscode-lldb)`

- + ` or [MS C++ tools](https://marketplace.visualstudio.com/items?itemName=ms-vscode.cpptools) extension for debugging.`);

- const workspace = !isMultiFolderWorkspace || !runnable.args.workspaceRoot ?

- firstWorkspace :

- workspaceFolders.find(w => runnable.args.workspaceRoot?.includes(w.uri.fsPath)) || firstWorkspace;

- const workspaceQualifier = isMultiFolderWorkspace ? `:${workspace.name}` : '';

- return path.normalize(p).replace(wsFolder, '${workspaceFolder' + workspaceQualifier + '}');

- const debugConfig = knownEngines[debugEngine.id](runnable, simplifyPath(executable), env, sourceFileMap);

- const cargo = new Cargo(runnable.args.workspaceRoot || '.', debugOutput);

-function getLldbDebugConfig(runnable: ra.Runnable, executable: string, env: Record<string, string>, sourceFileMap?: Record<string, string>): vscode.DebugConfiguration {

- env

-function getCppvsDebugConfig(runnable: ra.Runnable, executable: string, env: Record<string, string>, sourceFileMap?: Record<string, string>): vscode.DebugConfiguration {

- type: (os.platform() === "win32") ? "cppvsdbg" : "cppdbg",

-export const analyzerStatus = new lc.RequestType<AnalyzerStatusParams, string, void>("rust-analyzer/analyzerStatus");

-export const serverStatus = new lc.NotificationType<ServerStatusParams>("experimental/serverStatus");

-export const syntaxTree = new lc.RequestType<SyntaxTreeParams, string, void>("rust-analyzer/syntaxTree");

-export const viewHir = new lc.RequestType<lc.TextDocumentPositionParams, string, void>("rust-analyzer/viewHir");

-export const viewFileText = new lc.RequestType<lc.TextDocumentIdentifier, string, void>("rust-analyzer/viewFileText");

-export const viewItemTree = new lc.RequestType<ViewItemTreeParams, string, void>("rust-analyzer/viewItemTree");

-export const viewCrateGraph = new lc.RequestType<ViewCrateGraphParams, string, void>("rust-analyzer/viewCrateGraph");

-export const expandMacro = new lc.RequestType<ExpandMacroParams, ExpandedMacro | null, void>("rust-analyzer/expandMacro");

-export const matchingBrace = new lc.RequestType<MatchingBraceParams, lc.Position[], void>("experimental/matchingBrace");

-export const parentModule = new lc.RequestType<lc.TextDocumentPositionParams, lc.LocationLink[] | null, void>("experimental/parentModule");

-export const joinLines = new lc.RequestType<JoinLinesParams, lc.TextEdit[], void>("experimental/joinLines");

-export const onEnter = new lc.RequestType<lc.TextDocumentPositionParams, lc.TextEdit[], void>("experimental/onEnter");

-export const runnables = new lc.RequestType<RunnablesParams, Runnable[], void>("experimental/runnables");

-export const relatedTests = new lc.RequestType<lc.TextDocumentPositionParams, TestInfo[], void>("rust-analyzer/relatedTests");

-export const ssr = new lc.RequestType<SsrParams, lc.WorkspaceEdit, void>('experimental/ssr');

-export const openDocs = new lc.RequestType<lc.TextDocumentPositionParams, string | void, void>('experimental/externalDocs');

-export const openCargoToml = new lc.RequestType<OpenCargoTomlParams, lc.Location, void>("experimental/openCargoToml");

-export const moveItem = new lc.RequestType<MoveItemParams, lc.TextEdit[], void>("experimental/moveItem");

- Down = "Down"

-import * as vscode from 'vscode';

-import * as lc from 'vscode-languageclient/node';

-import * as commands from './commands';

-import { Ctx } from './ctx';

-import { Config } from './config';

-import { log, isValidExecutable, isRustDocument } from './util';

-import { PersistentState } from './persistent_state';

-import { activateTaskProvider } from './tasks';

-import { setContextValue } from './util';

-import { exec } from 'child_process';

-export async function activate(context: vscode.ExtensionContext): Promise<RustAnalyzerExtensionApi> {

- return await tryActivate(context).catch(err => {

- const serverPath = await bootstrap(context, config, state).catch(err => {

- const rustDocuments = vscode.workspace.textDocuments.filter(document => isRustDocument(document));

- ctx = await Ctx.create(config, context, serverPath, { kind: 'Detached Files', files: rustDocuments });

- _ => ctx?.client?.sendNotification('workspace/didChangeConfiguration', { settings: "" }).catch(log.error),

- ctx.subscriptions,

- client: ctx.client

- const defaultOnEnter = vscode.commands.registerCommand(

- 'rust-analyzer.onEnter',

- () => vscode.commands.executeCommand('default:type', { text: '\n' }),

- ctx.registerCommand('reload', _ => async () => {

- void vscode.window.showInformationMessage('Reloading rust-analyzer...');

- ctx.registerCommand('analyzerStatus', commands.analyzerStatus);

- ctx.registerCommand('memoryUsage', commands.memoryUsage);

- ctx.registerCommand('shuffleCrateGraph', commands.shuffleCrateGraph);

- ctx.registerCommand('reloadWorkspace', commands.reloadWorkspace);

- ctx.registerCommand('matchingBrace', commands.matchingBrace);

- ctx.registerCommand('joinLines', commands.joinLines);

- ctx.registerCommand('parentModule', commands.parentModule);

- ctx.registerCommand('syntaxTree', commands.syntaxTree);

- ctx.registerCommand('viewHir', commands.viewHir);

- ctx.registerCommand('viewFileText', commands.viewFileText);

- ctx.registerCommand('viewItemTree', commands.viewItemTree);

- ctx.registerCommand('viewCrateGraph', commands.viewCrateGraph);

- ctx.registerCommand('viewFullCrateGraph', commands.viewFullCrateGraph);

- ctx.registerCommand('expandMacro', commands.expandMacro);

- ctx.registerCommand('run', commands.run);

- ctx.registerCommand('copyRunCommandLine', commands.copyRunCommandLine);

- ctx.registerCommand('debug', commands.debug);

- ctx.registerCommand('newDebugConfig', commands.newDebugConfig);

- ctx.registerCommand('openDocs', commands.openDocs);

- ctx.registerCommand('openCargoToml', commands.openCargoToml);

- ctx.registerCommand('peekTests', commands.peekTests);

- ctx.registerCommand('moveItemUp', commands.moveItemUp);

- ctx.registerCommand('moveItemDown', commands.moveItemDown);

- ctx.registerCommand('onEnter', commands.onEnter);

- ctx.registerCommand('ssr', commands.ssr);

- ctx.registerCommand('serverVersion', commands.serverVersion);

- ctx.registerCommand('toggleInlayHints', commands.toggleInlayHints);

- ctx.registerCommand('runSingle', commands.runSingle);

- ctx.registerCommand('debugSingle', commands.debugSingle);

- ctx.registerCommand('showReferences', commands.showReferences);

- ctx.registerCommand('applySnippetWorkspaceEdit', commands.applySnippetWorkspaceEditCommand);

- ctx.registerCommand('resolveCodeAction', commands.resolveCodeAction);

- ctx.registerCommand('applyActionGroup', commands.applyActionGroup);

- ctx.registerCommand('gotoLocation', commands.gotoLocation);

-async function bootstrap(context: vscode.ExtensionContext, config: Config, state: PersistentState): Promise<string> {

- "Please, ensure its [proper installation](https://rust-analyzer.github.io/manual.html#installation)."

- title: "Patching rust-analyzer for NixOS"

- const handle = exec(`nix-build -E - --argstr srcStr '${origFile.fsPath}' -o '${dest.fsPath}'`,

- });

-async function getServer(context: vscode.ExtensionContext, config: Config, state: PersistentState): Promise<string | undefined> {

- };

- const bundledExists = await vscode.workspace.fs.stat(bundled).then(() => true, () => false);

- let exists = await vscode.workspace.fs.stat(dest).then(() => true, () => false);

- "You need to manually clone the rust-analyzer repository and " +

- "run `cargo xtask install --server` to build the language server from sources. " +

- "If you feel that your platform should be supported, please create an issue " +

- "about that [here](https://github.com/rust-analyzer/rust-analyzer/issues) and we " +

- "will consider it."

- const contents = (await vscode.workspace.fs.readFile(vscode.Uri.file("/etc/os-release"))).toString();

- const idString = contents.split('\n').find((a) => a.startsWith("ID=")) || "ID=linux";

- vscode.window.showWarningMessage(

- `You have both the rust-analyzer (rust-lang.rust-analyzer) and Rust (rust-lang.rust) ` +

- "plugins enabled. These are known to conflict and cause various functions of " +

- "both plugins to not work correctly. You should disable one of them.", "Got it")

- .then(() => { }, console.error);

- return vscode.languages.setLanguageConfiguration('rust', {

- action: { indentAction, appendText: '/// ' },

- action: { indentAction, appendText: '//! ' },

- action: { indentAction: vscode.IndentAction.IndentOutdent, appendText: ' * ' },

- action: { indentAction, appendText: ' * ' },

- action: { indentAction, appendText: '* ' },

-import * as vscode from 'vscode';

-import { log } from './util';

-import * as vscode from 'vscode';

-import * as lc from 'vscode-languageclient';

-import * as ra from './lsp_ext';

-import * as tasks from './tasks';

-

-import { Ctx } from './ctx';

-import { makeDebugConfig } from './debug';

-import { Config, RunnableEnvCfg } from './config';

-

-const quickPickButtons = [{ iconPath: new vscode.ThemeIcon("save"), tooltip: "Save as a launch.json configurtation." }];

-

-export async function selectRunnable(ctx: Ctx, prevRunnable?: RunnableQuickPick, debuggeeOnly = false, showButtons: boolean = true): Promise<RunnableQuickPick | undefined> {

- position: client.code2ProtocolConverter.asPosition(

- editor.selection.active,

- ),

- if (

- prevRunnable &&

- JSON.stringify(prevRunnable.runnable) === JSON.stringify(r)

- ) {

- if (debuggeeOnly && (r.label.startsWith('doctest') || r.label.startsWith('cargo'))) {

- disposables.forEach(d => d.dispose());

- if (active[0].label.startsWith('cargo')) {

-export function prepareEnv(runnable: ra.Runnable, runnableEnvCfg: RunnableEnvCfg): Record<string, string> {

- const env: Record<string, string> = { "RUST_BACKTRACE": "short" };

- const cargoTask = await tasks.buildCargoTask(target, definition, runnable.label, args, config.cargoRunner, true);

- args.push('--', ...runnable.args.executableArgs);

-import * as vscode from 'vscode';

-import { assert } from './util';

- if (editor) await editor.edit((builder) => {

- for (const indel of edits) {

- assert(!parseSnippet(indel.newText), `bad ws edit: snippet received with multiple edits: ${JSON.stringify(edit)}`);

- builder.replace(indel.range, indel.newText);

- }

- });

- return vscode.window.visibleTextEditors.find((it) => it.document.uri.toString() === uri.toString());

- const lastNewline = prefix.lastIndexOf('\n');

- const startColumn = lastNewline === -1 ?

- indel.range.start.character + placeholderStart

- : prefix.length - lastNewline - 1;

- selections.push(new vscode.Selection(

- new vscode.Position(startLine, startColumn),

- new vscode.Position(startLine, endColumn),

- ));

- lineDelta += countLines(indel.newText) - (indel.range.end.line - indel.range.start.line);

- if (m.index == null)

- return undefined;

-import * as vscode from 'vscode';

-import { Config } from './config';

-import { log } from './util';

-export const TASK_TYPE = 'cargo';

-export const TASK_SOURCE = 'rust';

- { command: 'build', group: vscode.TaskGroup.Build },

- { command: 'check', group: vscode.TaskGroup.Build },

- { command: 'test', group: vscode.TaskGroup.Test },

- { command: 'clean', group: vscode.TaskGroup.Clean },

- { command: 'run', group: undefined },

- const vscodeTask = await buildCargoTask(workspaceTarget, { type: TASK_TYPE, command: def.command }, `cargo ${def.command}`, [def.command], this.config.cargoRunner);

- return await buildCargoTask(task.scope, definition, task.name, args, this.config.cargoRunner);

-

-

- ['$rustc']

-import * as cp from 'child_process';

-import * as os from 'os';

-import * as path from 'path';

-import * as readline from 'readline';

-import * as vscode from 'vscode';

-import { execute, log, memoizeAsync } from './util';

- constructor(readonly rootFolder: string, readonly output: vscode.OutputChannel) { }

- case "run": cargoArgs[0] = "build"; break;

- result.filter = (artifacts) => artifacts.filter(it => it.isTest);

- await this.runCargo(spec.cargoArgs,

- message => {

- if (message.reason === 'compiler-artifact' && message.executable) {

- const isBinary = message.target.crate_types.includes('bin');

- const isBuildScript = message.target.kind.includes('custom-build');

- isTest: message.profile.test

- } else if (message.reason === 'compiler-message') {

- stderr => this.output.append(stderr),

- throw new Error('No compilation artifacts');

- throw new Error('Multiple compilation artifacts are not supported.');

- stdio: ['ignore', 'pipe', 'pipe'],

- cwd: this.rootFolder

- cargo.on('error', err => reject(new Error(`could not launch cargo: ${err}`)));

- cargo.stderr.on('data', chunk => onStderrString(chunk.toString()));

- rl.on('line', line => {

- cargo.on('exit', (exitCode, _) => {

- if (exitCode === 0)

- resolve(exitCode);

- else

- reject(new Error(`exit code: ${exitCode}.`));

- const standardPath = vscode.Uri.joinPath(vscode.Uri.file(os.homedir()), ".cargo", "bin", executableName);

- const paths = process.env.PATH ?? "";;

- const candidates = paths.split(path.delimiter).flatMap(dirInPath => {

- return os.type() === "Windows_NT"

- ? [candidate, `${candidate}.exe`]

- : [candidate];

-export const log = new class {

-};

- token?: vscode.CancellationToken,

- : client.sendRequest(reqType, param)

- );

- throw 'unreachable';

- return new Promise(resolve => setTimeout(resolve, ms));

- return document.languageId === 'rust' && document.uri.scheme === 'file';

- return document.uri.scheme === 'file' && document.fileName.endsWith('Cargo.toml');

- const res = spawnSync(path, ["--version"], { encoding: 'utf8' });

- const printOutput = res.error && (res.error as any).code !== 'ENOENT' ? log.warn : log.debug;

- return vscode.commands.executeCommand('setContext', key, value);

-export function memoizeAsync<Ret, TThis, Param extends string>(func: (this: TThis, arg: Param) => Promise<Ret>) {

- return async function(this: TThis, arg: Param) {

-import * as path from 'path';

-import * as fs from 'fs';

-import { runTests } from '@vscode/test-electron';

- const extensionDevelopmentPath = path.resolve(__dirname, '../../');

- const jsonData = fs.readFileSync(path.join(extensionDevelopmentPath, 'package.json'));

- if (minimalVersion.startsWith('^')) minimalVersion = minimalVersion.slice(1);

- const extensionTestsPath = path.resolve(__dirname, './unit/index');

- extensionTestsPath

- version: 'stable',

- extensionTestsPath

-main().catch(err => {

- console.error('Failed to run tests', err);

-import { readdir } from 'fs/promises';

-import * as path from 'path';

- const testFiles = (await readdir(path.resolve(__dirname))).filter(name => name.endsWith('.test.js'));

-import * as assert from 'assert';

-import { Cargo } from '../../src/toolchain';

-import { Context } from '.';

- await ctx.suite('Launch configuration/Lens', suite => {

- suite.addTest('A binary', async () => {

- const args = Cargo.artifactSpec(["build", "--package", "pkg_name", "--bin", "pkg_name"]);

- assert.deepStrictEqual(args.cargoArgs, ["build", "--package", "pkg_name", "--bin", "pkg_name", "--message-format=json"]);

- suite.addTest('One of Multiple Binaries', async () => {

- assert.deepStrictEqual(args.cargoArgs, ["build", "--package", "pkg_name", "--bin", "bin1", "--message-format=json"]);

- suite.addTest('A test', async () => {

- assert.deepStrictEqual(args.cargoArgs, ["test", "--package", "pkg_name", "--lib", "--no-run", "--message-format=json"]);

- await ctx.suite('Launch configuration/QuickPick', suite => {

- suite.addTest('A binary', async () => {

- assert.deepStrictEqual(args.cargoArgs, ["build", "--package", "pkg_name", "--bin", "pkg_name", "--message-format=json"]);

-

- suite.addTest('One of Multiple Binaries', async () => {

- assert.deepStrictEqual(args.cargoArgs, ["build", "--package", "pkg_name", "--bin", "bin2", "--message-format=json"]);

- suite.addTest('A test', async () => {

- assert.deepStrictEqual(args.cargoArgs, ["test", "--package", "pkg_name", "--lib", "--message-format=json", "--no-run"]);

-import * as assert from 'assert';

-import { prepareEnv } from '../../src/run';

-import { RunnableEnvCfg } from '../../src/config';

-import { Context } from '.';

-import * as ra from '../../src/lsp_ext';

- cargoExtraArgs: []

- }

- await ctx.suite('Runnable env', suite => {

- suite.addTest('Global config works', async () => {

- const binEnv = fakePrepareEnv("run project_name", { "GLOBAL": "g" });

- const testEnv = fakePrepareEnv("test some::mod::test_name", { "GLOBAL": "g" });

- suite.addTest('null mask works', async () => {

- env: { DATA: "data" }

- }

- suite.addTest('order works', async () => {

- env: { DATA: "data" }

- env: { DATA: "newdata" }

- }

- suite.addTest('mask works', async () => {

- env: { DATA: "data" }

- env: { DATA: "rundata" }

- env: { DATA: "special_test" }

- }

- suite.addTest('exact test name works', async () => {

- env: { DATA: "data" }

- env: { DATA: "test special" }

- }

- suite.addTest('test mod name works', async () => {

- env: { DATA: "data" }

- env: { DATA: "mod special" }

- }

-import * as assert from 'assert';

-import { Context } from '.';

-import { substituteVariablesInEnv } from '../../src/config';

- await ctx.suite('Server Env Settings', suite => {

- suite.addTest('Replacing Env Variables', async () => {

- MY_VAR: "test"

- MY_VAR: "test"

- suite.addTest('Circular dependencies remain as is', async () => {

- F_USES_E: "${env:E_IS_ISOLATED}"

- F_USES_E: "test"

- suite.addTest('Should support external variables', async () => {

- USING_EXTERNAL_VAR: "${env:TEST_VARIABLE} test ${env:TEST_VARIABLE}"

- USING_EXTERNAL_VAR: "test test test"

- suite.addTest('should support VSCode variables', async () => {

- USING_VSCODE_VAR: "${workspaceFolderBasename}"

- assert.deepStrictEqual(actualEnv.USING_VSCODE_VAR, 'code');

- "extends": "./tsconfig.json",

- "include": [

- // repeated from base config's "include" setting

- "src",

- "tests",

- // these are the eslint-only inclusions

- ".eslintrc.js",

- ]

- "lib": [

- "es2021"

- ],

- "exclude": [

- "node_modules",

- ".vscode-test"

- ],

- "include": [

- "src",

- "tests"

- ]