language-servers/rust-analyzer
1
0
Fork 0
mirror of https://github.com/rust-lang/rust-analyzer.git synced 2025-08-22 03:14:30 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 3

Merge remote-tracking branch 'upstream/master' into uniformed_debug_lens

Browse source 
# Conflicts:
#	editors/code/src/commands/runnables.ts
This commit is contained in:
vsrs 2020-05-08 19:34:34 +03:00
commit 0ef17ef1ee
75 changed files with 2407 additions and 1029 deletions
Download patch file Download diff file Expand all files Collapse all files

16
editors/code/package.json
View file

@ -300,6 +300,11 @@
"default": true,
"markdownDescription": "Check with all features (will be passed as `--all-features`)"
},
"rust-analyzer.inlayHints.enable": {
"type": "boolean",
"default": true,
"description": "Disable all inlay hints"
},
"rust-analyzer.inlayHints.typeHints": {
"type": "boolean",
"default": true,
@ -405,7 +410,7 @@
"ms-vscode.cpptools"
],
"default": "auto",
"description": "Preffered debug engine.",
"description": "Preferred debug engine.",
"markdownEnumDescriptions": [
"First try to use [CodeLLDB](https://marketplace.visualstudio.com/items?itemName=vadimcn.vscode-lldb), if it's not installed try to use [MS C++ tools](https://marketplace.visualstudio.com/items?itemName=ms-vscode.cpptools).",
"Use [CodeLLDB](https://marketplace.visualstudio.com/items?itemName=vadimcn.vscode-lldb)",
@ -599,9 +604,18 @@
"union": [
"entity.name.union"
],
"struct": [
"entity.name.type.struct"
],
"keyword.unsafe": [
"keyword.other.unsafe"
],
"keyword": [
"keyword"
],
"keyword.controlFlow": [
"keyword.control"
],
"variable.constant": [
"entity.name.constant"
]

81
editors/code/src/cargo.ts
View file

@ -1,6 +1,9 @@
import * as cp from 'child_process';
import * as os from 'os';
import * as path from 'path';
import * as readline from 'readline';
import { OutputChannel } from 'vscode';
import { isValidExecutable } from './util';
interface CompilationArtifact {
fileName: string;
@ -10,17 +13,9 @@ interface CompilationArtifact {
}
export class Cargo {
rootFolder: string;
env?: Record<string, string>;
output: OutputChannel;
constructor(readonly rootFolder: string, readonly output: OutputChannel) { }
public constructor(cargoTomlFolder: string, output: OutputChannel, env: Record<string, string> | undefined = undefined) {
this.rootFolder = cargoTomlFolder;
this.output = output;
this.env = env;
}
public async artifactsFromArgs(cargoArgs: string[]): Promise<CompilationArtifact[]> {
private async artifactsFromArgs(cargoArgs: string[]): Promise<CompilationArtifact[]> {
const artifacts: CompilationArtifact[] = [];
try {
@ -37,17 +32,13 @@ export class Cargo {
isTest: message.profile.test
});
}
}
else if (message.reason === 'compiler-message') {
} else if (message.reason === 'compiler-message') {
this.output.append(message.message.rendered);
}
},
stderr => {
this.output.append(stderr);
}
stderr => this.output.append(stderr),
);
}
catch (err) {
} catch (err) {
this.output.show(true);
throw new Error(`Cargo invocation has failed: ${err}`);
}
@ -55,9 +46,8 @@ export class Cargo {
return artifacts;
}
public async executableFromArgs(args: string[]): Promise<string> {
const cargoArgs = [...args]; // to remain args unchanged
cargoArgs.push("--message-format=json");
async executableFromArgs(args: readonly string[]): Promise<string> {
const cargoArgs = [...args, "--message-format=json"];
const artifacts = await this.artifactsFromArgs(cargoArgs);
@ -70,24 +60,27 @@ export class Cargo {
return artifacts[0].fileName;
}
runCargo(
private runCargo(
cargoArgs: string[],
onStdoutJson: (obj: any) => void,
onStderrString: (data: string) => void
): Promise<number> {
return new Promise<number>((resolve, reject) => {
const cargo = cp.spawn('cargo', cargoArgs, {
return new Promise((resolve, reject) => {
let cargoPath;
try {
cargoPath = getCargoPathOrFail();
} catch (err) {
return reject(err);
}
const cargo = cp.spawn(cargoPath, cargoArgs, {
stdio: ['ignore', 'pipe', 'pipe'],
cwd: this.rootFolder,
env: this.env,
cwd: this.rootFolder
});
cargo.on('error', err => {
reject(new Error(`could not launch cargo: ${err}`));
});
cargo.stderr.on('data', chunk => {
onStderrString(chunk.toString());
});
cargo.on('error', err => reject(new Error(`could not launch cargo: ${err}`)));
cargo.stderr.on('data', chunk => onStderrString(chunk.toString()));
const rl = readline.createInterface({ input: cargo.stdout });
rl.on('line', line => {
@ -103,4 +96,28 @@ export class Cargo {
});
});
}
}
}
// Mirrors `ra_env::get_path_for_executable` implementation
function getCargoPathOrFail(): string {
const envVar = process.env.CARGO;
const executableName = "cargo";
if (envVar) {
if (isValidExecutable(envVar)) return envVar;
throw new Error(`\`${envVar}\` environment variable points to something that's not a valid executable`);
}
if (isValidExecutable(executableName)) return executableName;
const standardLocation = path.join(os.homedir(), '.cargo', 'bin', executableName);
if (isValidExecutable(standardLocation)) return standardLocation;
throw new Error(
`Failed to find \`${executableName}\` executable. ` +
`Make sure \`${executableName}\` is in \`$PATH\`, ` +
`or set \`${envVar}\` to point to a valid executable.`
);
}

1
editors/code/src/config.ts
View file

@ -94,6 +94,7 @@ export class Config {
get inlayHints() {
return {
enable: this.get<boolean>("inlayHints.enable"),
typeHints: this.get<boolean>("inlayHints.typeHints"),
parameterHints: this.get<boolean>("inlayHints.parameterHints"),
chainingHints: this.get<boolean>("inlayHints.chainingHints"),

14
editors/code/src/inlay_hints.ts
View file

@ -10,13 +10,13 @@ export function activateInlayHints(ctx: Ctx) {
const maybeUpdater = {
updater: null as null | HintsUpdater,
async onConfigChange() {
if (
!ctx.config.inlayHints.typeHints &&
!ctx.config.inlayHints.parameterHints &&
!ctx.config.inlayHints.chainingHints
) {
return this.dispose();
}
const anyEnabled = ctx.config.inlayHints.typeHints
|| ctx.config.inlayHints.parameterHints
|| ctx.config.inlayHints.chainingHints;
const enabled = ctx.config.inlayHints.enable && anyEnabled;
if (!enabled) return this.dispose();
await sleep(100);
if (this.updater) {
this.updater.syncCacheAndRenderHints();

8
editors/code/src/main.ts
View file

@ -8,10 +8,9 @@ import { activateInlayHints } from './inlay_hints';
import { activateStatusDisplay } from './status_display';
import { Ctx } from './ctx';
import { Config, NIGHTLY_TAG } from './config';
import { log, assert } from './util';
import { log, assert, isValidExecutable } from './util';
import { PersistentState } from './persistent_state';
import { fetchRelease, download } from './net';
import { spawnSync } from 'child_process';
import { activateTaskProvider } from './tasks';
let ctx: Ctx | undefined;
@ -179,10 +178,7 @@ async function bootstrapServer(config: Config, state: PersistentState): Promise<
log.debug("Using server binary at", path);
const res = spawnSync(path, ["--version"], { encoding: 'utf8' });
log.debug("Checked binary availability via --version", res);
log.debug(res, "--version output:", res.output);
if (res.status !== 0) {
if (!isValidExecutable(path)) {
throw new Error(`Failed to execute ${path} --version`);
}

11
editors/code/src/util.ts
View file

@ -1,6 +1,7 @@
import * as lc from "vscode-languageclient";
import * as vscode from "vscode";
import { strict as nativeAssert } from "assert";
import { spawnSync } from "child_process";
export function assert(condition: boolean, explanation: string): asserts condition {
try {
@ -82,3 +83,13 @@ export function isRustDocument(document: vscode.TextDocument): document is RustD
export function isRustEditor(editor: vscode.TextEditor): editor is RustEditor {
return isRustDocument(editor.document);
}
export function isValidExecutable(path: string): boolean {
log.debug("Checking availability of a binary at", path);
const res = spawnSync(path, ["--version"], { encoding: 'utf8' });
log.debug(res, "--version output:", res.output);
return res.status === 0;
}