Run subprocesses async in vscode extension

Author: darichey

src/tools/rust-analyzer/editors/code/src/bootstrap.ts

@@ -1,9 +1,9 @@
 import*asvscodefrom"vscode";
 import*asosfrom"os";
 importtype{Config}from"./config";
-import{typeEnv,log}from"./util";
+import{typeEnv,log,spawnAsync}from"./util";
 importtype{PersistentState}from"./persistent_state";
-import{exec,spawnSync}from"child_process";
+import{exec}from"child_process";
 import{TextDecoder}from"node:util";
 
 exportasyncfunctionbootstrap(
@@ -61,13 +61,12 @@ async function getServer(
 // if so, use the rust-analyzer component
 consttoolchainUri=vscode.Uri.joinPath(workspaceFolder.uri,"rust-toolchain.toml");
 if(awaithasToolchainFileWithRaDeclared(toolchainUri)){
-constres=spawnSync("rustup",["which","rust-analyzer"],{
-encoding: "utf8",
+constres=awaitspawnAsync("rustup",["which","rust-analyzer"],{
 env: { ...process.env},
 cwd: workspaceFolder.uri.fsPath,
 });
 if(!res.error&&res.status===0){
-toolchainServerPath=earliestToolchainPath(
+toolchainServerPath=awaitearliestToolchainPath(
 toolchainServerPath,
 res.stdout.trim(),
 raVersionResolver,
@@ -114,10 +113,8 @@ async function getServer(
 }
 
 // Given a path to a rust-analyzer executable, resolve its version and return it.
-functionraVersionResolver(path: string): string|undefined{
-constres=spawnSync(path,["--version"],{
-encoding: "utf8",
-});
+asyncfunctionraVersionResolver(path: string): Promise<string|undefined>{
+constres=awaitspawnAsync(path,["--version"]);
 if(!res.error&&res.status===0){
 returnres.stdout;
 }else{
@@ -126,13 +123,16 @@ function raVersionResolver(path: string): string | undefined {
 }
 
 // Given a path to two rust-analyzer executables, return the earliest one by date.
-functionearliestToolchainPath(
+asyncfunctionearliestToolchainPath(
 path0: string|undefined,
 path1: string,
-raVersionResolver: (path: string)=>string|undefined,
-): string{
+raVersionResolver: (path: string)=>Promise<string|undefined>,
+): Promise<string>{
 if(path0){
-if(orderFromPath(path0,raVersionResolver)<orderFromPath(path1,raVersionResolver)){
+if(
+(awaitorderFromPath(path0,raVersionResolver))<
+(awaitorderFromPath(path1,raVersionResolver))
+){
 returnpath0;
 }else{
 returnpath1;
@@ -150,11 +150,11 @@ function earliestToolchainPath(
 // nightly - /Users/myuser/.rustup/toolchains/nightly-2022-11-22-aarch64-apple-darwin/bin/rust-analyzer
 // versioned - /Users/myuser/.rustup/toolchains/1.72.1-aarch64-apple-darwin/bin/rust-analyzer
 // stable - /Users/myuser/.rustup/toolchains/stable-aarch64-apple-darwin/bin/rust-analyzer
-functionorderFromPath(
+asyncfunctionorderFromPath(
 path: string,
-raVersionResolver: (path: string)=>string|undefined,
-): string{
-constraVersion=raVersionResolver(path);
+raVersionResolver: (path: string)=>Promise<string|undefined>,
+): Promise<string>{
+constraVersion=awaitraVersionResolver(path);
 constraDate=raVersion?.match(/^rust-analyzer.*\(.*(\d{4}-\d{2}-\d{2})\)$/);
 if(raDate?.length===2){
 constprecedence=path.includes("nightly-") ? "0" : "1";
@@ -184,11 +184,10 @@ async function hasToolchainFileWithRaDeclared(uri: vscode.Uri): Promise<boolean>
 }
 }
 
-exportfunctionisValidExecutable(path: string,extraEnv: Env): boolean{
+exportasyncfunctionisValidExecutable(path: string,extraEnv: Env): Promise<boolean>{
 log.debug("Checking availability of a binary at",path);
 
-constres=spawnSync(path,["--version"],{
-encoding: "utf8",
+constres=awaitspawnAsync(path,["--version"],{
 env: { ...process.env, ...extraEnv},
 });
 

src/tools/rust-analyzer/editors/code/src/util.ts

@@ -1,6 +1,6 @@
 import*asvscodefrom"vscode";
 import{strictasnativeAssert}from"assert";
-import{exec,typeExecOptions}from"child_process";
+import{exec,spawn,typeSpawnOptionsWithoutStdio,typeExecOptions}from"child_process";
 import{inspect}from"util";
 importtype{CargoRunnableArgs,ShellRunnableArgs}from"./lsp_ext";
 
@@ -233,3 +233,55 @@ export function expectNotUndefined<T>(input: Undefinable<T>, msg: string): NotUn
 exportfunctionunwrapUndefinable<T>(input: Undefinable<T>): NotUndefined<T>{
 returnexpectNotUndefined(input,`unwrapping \`undefined\``);
 }
+
+interfaceSpawnAsyncReturns{
+stdout: string;
+stderr: string;
+status: number|null;
+error?: Error|undefined;
+}
+
+exportasyncfunctionspawnAsync(
+path: string,
+args?: ReadonlyArray<string>,
+options?: SpawnOptionsWithoutStdio,
+): Promise<SpawnAsyncReturns>{
+constchild=spawn(path,args,options);
+conststdout: Array<Buffer>=[];
+conststderr: Array<Buffer>=[];
+try{
+constres=awaitnewPromise<{stdout: string;stderr: string;status: number|null}>(
+(resolve,reject)=>{
+child.stdout.on("data",(chunk)=>stdout.push(Buffer.from(chunk)));
+child.stderr.on("data",(chunk)=>stderr.push(Buffer.from(chunk)));
+child.on("error",(error)=>
+reject({
+stdout: Buffer.concat(stdout).toString("utf8"),
+stderr: Buffer.concat(stderr).toString("utf8"),
+ error,
+}),
+);
+child.on("close",(status)=>
+resolve({
+stdout: Buffer.concat(stdout).toString("utf8"),
+stderr: Buffer.concat(stderr).toString("utf8"),
+ status,
+}),
+);
+},
+);
+
+return{
+stdout: res.stdout,
+stderr: res.stderr,
+status: res.status,
+};
+}catch(e: any){
+return{
+stdout: e.stdout,
+stderr: e.stderr,
+status: e.status,
+error: e.error,
+};
+}
+}

src/tools/rust-analyzer/editors/code/tests/unit/bootstrap.test.ts

@@ -6,9 +6,9 @@ export async function getTests(ctx: Context) {
 awaitctx.suite("Bootstrap/Select toolchain RA",(suite)=>{
 suite.addTest("Order of nightly RA",async()=>{
 assert.deepStrictEqual(
-_private.orderFromPath(
+await_private.orderFromPath(
 "/Users/myuser/.rustup/toolchains/nightly-2022-11-22-aarch64-apple-darwin/bin/rust-analyzer",
-function(path: string){
+asyncfunction(path: string){
 assert.deepStrictEqual(
 path,
 "/Users/myuser/.rustup/toolchains/nightly-2022-11-22-aarch64-apple-darwin/bin/rust-analyzer",
@@ -22,9 +22,9 @@ export async function getTests(ctx: Context) {
 
 suite.addTest("Order of versioned RA",async()=>{
 assert.deepStrictEqual(
-_private.orderFromPath(
+await_private.orderFromPath(
 "/Users/myuser/.rustup/toolchains/1.72.1-aarch64-apple-darwin/bin/rust-analyzer",
-function(path: string){
+asyncfunction(path: string){
 assert.deepStrictEqual(
 path,
 "/Users/myuser/.rustup/toolchains/1.72.1-aarch64-apple-darwin/bin/rust-analyzer",
@@ -38,9 +38,9 @@ export async function getTests(ctx: Context) {
 
 suite.addTest("Order of versioned RA when unable to obtain version date",async()=>{
 assert.deepStrictEqual(
-_private.orderFromPath(
+await_private.orderFromPath(
 "/Users/myuser/.rustup/toolchains/1.72.1-aarch64-apple-darwin/bin/rust-analyzer",
-function(){
+asyncfunction(){
 return"rust-analyzer 1.72.1";
 },
 ),
@@ -50,9 +50,9 @@ export async function getTests(ctx: Context) {
 
 suite.addTest("Order of stable RA",async()=>{
 assert.deepStrictEqual(
-_private.orderFromPath(
+await_private.orderFromPath(
 "/Users/myuser/.rustup/toolchains/stable-aarch64-apple-darwin/bin/rust-analyzer",
-function(path: string){
+asyncfunction(path: string){
 assert.deepStrictEqual(
 path,
 "/Users/myuser/.rustup/toolchains/stable-aarch64-apple-darwin/bin/rust-analyzer",
@@ -66,7 +66,7 @@ export async function getTests(ctx: Context) {
 
 suite.addTest("Order with invalid path to RA",async()=>{
 assert.deepStrictEqual(
-_private.orderFromPath("some-weird-path",function(){
+await_private.orderFromPath("some-weird-path",asyncfunction(){
 returnundefined;
 }),
 "2",
@@ -75,10 +75,10 @@ export async function getTests(ctx: Context) {
 
 suite.addTest("Earliest RA between nightly and stable",async()=>{
 assert.deepStrictEqual(
-_private.earliestToolchainPath(
+await_private.earliestToolchainPath(
 "/Users/myuser/.rustup/toolchains/stable-aarch64-apple-darwin/bin/rust-analyzer",
 "/Users/myuser/.rustup/toolchains/nightly-2022-11-22-aarch64-apple-darwin/bin/rust-analyzer",
-function(path: string){
+asyncfunction(path: string){
 if(
 path===
 "/Users/myuser/.rustup/toolchains/nightly-2022-11-22-aarch64-apple-darwin/bin/rust-analyzer"