refactor: simplify shimExecFile with generic type and Reflect.apply

Replace `as unknown as` cast chains with a generic type parameter and
Reflect.apply for type-safe argument forwarding. Preserve the custom
promisify symbol using Reflect.get/set instead of manual symbol casts.

Author: EhabY

test/utils/platform.test.ts

@@ -115,7 +115,7 @@ describe("platform utils", () => {
 	describe("shimExecFile", () => {
 		const tmp = path.join(os.tmpdir(), "vscode-coder-tests-shim");
 		const mod = shimExecFile(cp);
-		const shimmedExecFile = promisify(mod.execFile);
+		const execFileAsync = promisify(mod.execFile);
 
 		beforeAll(async () => {
 			await fs.rm(tmp, { recursive: true, force: true });
@@ -128,7 +128,7 @@ describe("platform utils", () => {
 				"echo",
 				'process.stdout.write("ok");',
 			);
-			const { stdout } = await shimmedExecFile(script);
+			const { stdout } = await execFileAsync(script);
 			expect(stdout).toBe("ok");
 		});
 
@@ -138,24 +138,28 @@ describe("platform utils", () => {
 				"echo-args",
 				"process.stdout.write(process.argv.slice(2).join(','));",
 			);
-			const { stdout } = await shimmedExecFile(script, ["a", "b", "c"]);
+			const { stdout } = await execFileAsync(script, ["a", "b", "c"]);
 			expect(stdout).toBe("a,b,c");
 		});
 
 		it("does not rewrite non-.js files", async () => {
-			await expect(shimmedExecFile("/nonexistent/binary")).rejects.toThrow(
+			await expect(execFileAsync("/nonexistent/binary")).rejects.toThrow(
 				"ENOENT",
 			);
 		});
 
 		it("preserves the callback form", async () => {
-			const script = path.join(tmp, "echo.js");
+			const script = await writeExecutable(
+				tmp,
+				"cb-echo",
+				'process.stdout.write("cb");',
+			);
 			const stdout = await new Promise<string>((resolve, reject) => {
 				mod.execFile(script, (err, out) =>
 					err ? reject(new Error(err.message)) : resolve(out),
 				);
 			});
-			expect(stdout).toBe("ok");
+			expect(stdout).toBe("cb");
 		});
 
 		it("does not touch spawn", () => {

test/utils/platform.ts

@@ -3,7 +3,7 @@ import os from "node:os";
 import path from "node:path";
 import { expect } from "vitest";
 
-import type { ChildProcess } from "node:child_process";
+import type * as cp from "node:child_process";
 
 export function isWindows(): boolean {
 	return os.platform() === "win32";
@@ -79,23 +79,26 @@ function prepend(file: string, rest: unknown[]): [string, ...unknown[]] {
  * });
  * ```
  */
-type ChildProcessModule = typeof import("node:child_process");
-type Callable = (...args: unknown[]) => unknown;
+export function shimExecFile<
+	M extends { execFile: (...args: never[]) => unknown },
+>(mod: M): M {
+	const { execFile: original } = mod;
 
-export function shimExecFile(mod: ChildProcessModule): ChildProcessModule {
-	const { execFile: original, ...rest } = mod;
-
-	const execFile = (file: string, ...args: unknown[]): ChildProcess =>
-		(original as unknown as Callable)(...prepend(file, args)) as ChildProcess;
+	function execFile(file: string, ...rest: unknown[]): cp.ChildProcess {
+		return Reflect.apply(original, undefined, prepend(file, rest));
+	}
 
 	const sym = Symbol.for("nodejs.util.promisify.custom");
-	const originalCustom = (original as unknown as Record<symbol, Callable>)[sym];
-	(execFile as unknown as Record<symbol, unknown>)[sym] = (
-		file: string,
-		...args: unknown[]
-	): unknown => originalCustom(...prepend(file, args));
+	const customPromisify = Reflect.get(original, sym) as
+		| ((...args: unknown[]) => unknown)
+		| undefined;
+	if (customPromisify) {
+		Reflect.set(execFile, sym, (file: string, ...rest: unknown[]) =>
+			Reflect.apply(customPromisify, undefined, prepend(file, rest)),
+		);
+	}
 
-	return { ...rest, execFile } as ChildProcessModule;
+	return Object.assign({}, mod, { execFile });
 }
 
 export function expectPathsEqual(actual: string, expected: string) {