Ensure string prototypes extension extends are unique enough (#18870)

Author: Kartik Raj

src/client/common/extensions.ts

@@ -20,12 +20,12 @@ declare interface String {
      * Appropriately formats a string so it can be used as an argument for a command in a shell.
      * E.g. if an argument contains a space, then it will be enclosed within double quotes.
      */
-    toCommandArgument(): string;
+    toCommandArgumentForPythonExt(): string;
     /**
      * Appropriately formats a a file path so it can be used as an argument for a command in a shell.
      * E.g. if an argument contains a space, then it will be enclosed within double quotes.
      */
-    fileToCommandArgument(): string;
+    fileToCommandArgumentForPythonExt(): string;
     /**
      * String.format() implementation.
      * Tokens such as {0}, {1} will be replaced with corresponding positional arguments.
@@ -69,7 +69,7 @@ String.prototype.splitLines = function (
  * E.g. if an argument contains a space, then it will be enclosed within double quotes.
  * @param {String} value.
  */
-String.prototype.toCommandArgument = function (this: string): string {
+String.prototype.toCommandArgumentForPythonExt = function (this: string): string {
     if (!this) {
         return this;
     }
@@ -82,11 +82,11 @@ String.prototype.toCommandArgument = function (this: string): string {
  * Appropriately formats a a file path so it can be used as an argument for a command in a shell.
  * E.g. if an argument contains a space, then it will be enclosed within double quotes.
  */
-String.prototype.fileToCommandArgument = function (this: string): string {
+String.prototype.fileToCommandArgumentForPythonExt = function (this: string): string {
     if (!this) {
         return this;
     }
-    return this.toCommandArgument().replace(/\\/g, '/');
+    return this.toCommandArgumentForPythonExt().replace(/\\/g, '/');
 };
 
 /**

src/client/common/installer/condaInstaller.ts

@@ -104,11 +104,11 @@ export class CondaInstaller extends ModuleInstaller {
         if (info && info.name) {
             // If we have the name of the conda environment, then use that.
             args.push('--name');
-            args.push(info.name.toCommandArgument());
+            args.push(info.name.toCommandArgumentForPythonExt());
         } else if (info && info.path) {
             // Else provide the full path to the environment path.
             args.push('--prefix');
-            args.push(info.path.fileToCommandArgument());
+            args.push(info.path.fileToCommandArgumentForPythonExt());
         }
         if (flags & ModuleInstallFlags.updateDependencies) {
             args.push('--update-deps');

src/client/common/installer/moduleInstaller.ts

@@ -217,7 +217,8 @@ export abstract class ModuleInstaller implements IModuleInstaller {
                 const argv = [command, ...args];
                 // Concat these together to make a set of quoted strings
                 const quoted = argv.reduce(
-                    (p, c) => (p ? `${p} ${c.toCommandArgument()}` : `${c.toCommandArgument()}`),
+                    (p, c) =>
+                        p ? `${p} ${c.toCommandArgumentForPythonExt()}` : `${c.toCommandArgumentForPythonExt()}`,
                     '',
                 );
                 await processService.shellExec(quoted);

src/client/common/process/internal/scripts/index.ts

@@ -94,7 +94,7 @@ export function normalizeSelection(): [string[], (out: string) => string] {
 // printEnvVariables.py
 
 export function printEnvVariables(): [string[], (out: string) => NodeJS.ProcessEnv] {
-    const script = path.join(SCRIPTS_DIR, 'printEnvVariables.py').fileToCommandArgument();
+    const script = path.join(SCRIPTS_DIR, 'printEnvVariables.py').fileToCommandArgumentForPythonExt();
     const args = [script];
 
     function parse(out: string): NodeJS.ProcessEnv {
@@ -113,11 +113,11 @@ export function shell_exec(command: string, lockfile: string, shellArgs: string[
     // could be anything.
     return [
         script,
-        command.fileToCommandArgument(),
+        command.fileToCommandArgumentForPythonExt(),
         // The shell args must come after the command
         // but before the lockfile.
         ...shellArgs,
-        lockfile.fileToCommandArgument(),
+        lockfile.fileToCommandArgumentForPythonExt(),
     ];
 }
 

src/client/common/process/logger.ts

@@ -22,7 +22,7 @@ export class ProcessLogger implements IProcessLogger {
             return;
         }
         let command = args
-            ? [fileOrCommand, ...args].map((e) => e.trimQuotes().toCommandArgument()).join(' ')
+            ? [fileOrCommand, ...args].map((e) => e.trimQuotes().toCommandArgumentForPythonExt()).join(' ')
             : fileOrCommand;
         const info = [`> ${this.getDisplayCommands(command)}`];
         if (options && options.cwd) {

src/client/common/terminal/environmentActivationProviders/bash.ts

@@ -46,6 +46,6 @@ export class Bash extends VenvBaseActivationCommandProvider {
         if (!scriptFile) {
             return;
         }
-        return [`source ${scriptFile.fileToCommandArgument()}`];
+        return [`source ${scriptFile.fileToCommandArgumentForPythonExt()}`];
     }
 }

src/client/common/terminal/environmentActivationProviders/commandPrompt.ts

@@ -66,12 +66,12 @@ export class CommandPromptAndPowerShell extends VenvBaseActivationCommandProvide
         }
 
         if (targetShell === TerminalShellType.commandPrompt && scriptFile.endsWith('activate.bat')) {
-            return [scriptFile.fileToCommandArgument()];
+            return [scriptFile.fileToCommandArgumentForPythonExt()];
         } else if (
             (targetShell === TerminalShellType.powershell || targetShell === TerminalShellType.powershellCore) &&
             scriptFile.endsWith('Activate.ps1')
         ) {
-            return [`& ${scriptFile.fileToCommandArgument()}`];
+            return [`& ${scriptFile.fileToCommandArgumentForPythonExt()}`];
         } else if (targetShell === TerminalShellType.commandPrompt && scriptFile.endsWith('Activate.ps1')) {
             // lets not try to run the powershell file from command prompt (user may not have powershell)
             return [];

src/client/common/terminal/environmentActivationProviders/condaActivationProvider.ts

@@ -83,9 +83,11 @@ export class CondaActivationCommandProvider implements ITerminalActivationComman
                 const interpreterPath = await this.condaService.getInterpreterPathForEnvironment(envInfo);
                 const condaPath = await this.condaService.getCondaFileFromInterpreter(interpreterPath, envInfo.name);
                 if (condaPath) {
-                    const activatePath = path.join(path.dirname(condaPath), 'activate').fileToCommandArgument();
+                    const activatePath = path
+                        .join(path.dirname(condaPath), 'activate')
+                        .fileToCommandArgumentForPythonExt();
                     const firstActivate = this.platform.isWindows ? activatePath : `source ${activatePath}`;
-                    return [firstActivate, `conda activate ${condaEnv.toCommandArgument()}`];
+                    return [firstActivate, `conda activate ${condaEnv.toCommandArgumentForPythonExt()}`];
                 }
             }
         }
@@ -116,15 +118,15 @@ export class CondaActivationCommandProvider implements ITerminalActivationComman
             const condaScriptsPath: string = path.dirname(condaExePath);
             // prefix the cmd with the found path, and ensure it's quoted properly
             activateCmd = path.join(condaScriptsPath, activateCmd);
-            activateCmd = activateCmd.toCommandArgument();
+            activateCmd = activateCmd.toCommandArgumentForPythonExt();
         }
 
         return activateCmd;
     }
 
     public async getWindowsCommands(condaEnv: string): Promise<string[] | undefined> {
         const activate = await this.getWindowsActivateCommand();
-        return [`${activate} ${condaEnv.toCommandArgument()}`];
+        return [`${activate} ${condaEnv.toCommandArgumentForPythonExt()}`];
     }
 }
 
@@ -135,16 +137,16 @@ export class CondaActivationCommandProvider implements ITerminalActivationComman
  * Extension will not attempt to work around issues by trying to setup shell for user.
  */
 export async function _getPowershellCommands(condaEnv: string): Promise<string[] | undefined> {
-    return [`conda activate ${condaEnv.toCommandArgument()}`];
+    return [`conda activate ${condaEnv.toCommandArgumentForPythonExt()}`];
 }
 
 async function getFishCommands(condaEnv: string, condaFile: string): Promise<string[] | undefined> {
     // https://github.com/conda/conda/blob/be8c08c083f4d5e05b06bd2689d2cd0d410c2ffe/shell/etc/fish/conf.d/conda.fish#L18-L28
-    return [`${condaFile.fileToCommandArgument()} activate ${condaEnv.toCommandArgument()}`];
+    return [`${condaFile.fileToCommandArgumentForPythonExt()} activate ${condaEnv.toCommandArgumentForPythonExt()}`];
 }
 
 async function getUnixCommands(condaEnv: string, condaFile: string): Promise<string[] | undefined> {
     const condaDir = path.dirname(condaFile);
     const activateFile = path.join(condaDir, 'activate');
-    return [`source ${activateFile.fileToCommandArgument()} ${condaEnv.toCommandArgument()}`];
+    return [`source ${activateFile.fileToCommandArgumentForPythonExt()} ${condaEnv.toCommandArgumentForPythonExt()}`];
 }

src/client/common/terminal/environmentActivationProviders/pipEnvActivationProvider.ts

@@ -41,7 +41,7 @@ export class PipEnvActivationCommandProvider implements ITerminalActivationComma
             }
         }
         const execName = this.pipEnvExecution.executable;
-        return [`${execName.fileToCommandArgument()} shell`];
+        return [`${execName.fileToCommandArgumentForPythonExt()} shell`];
     }
 
     public async getActivationCommandsForInterpreter(pythonPath: string): Promise<string[] | undefined> {
@@ -51,6 +51,6 @@ export class PipEnvActivationCommandProvider implements ITerminalActivationComma
         }
 
         const execName = this.pipEnvExecution.executable;
-        return [`${execName.fileToCommandArgument()} shell`];
+        return [`${execName.fileToCommandArgumentForPythonExt()} shell`];
     }
 }

src/client/common/terminal/environmentActivationProviders/pyenvActivationProvider.ts

@@ -26,7 +26,7 @@ export class PyEnvActivationCommandProvider implements ITerminalActivationComman
             return;
         }
 
-        return [`pyenv shell ${interpreter.envName.toCommandArgument()}`];
+        return [`pyenv shell ${interpreter.envName.toCommandArgumentForPythonExt()}`];
     }
 
     public async getActivationCommandsForInterpreter(
@@ -40,6 +40,6 @@ export class PyEnvActivationCommandProvider implements ITerminalActivationComman
             return;
         }
 
-        return [`pyenv shell ${interpreter.envName.toCommandArgument()}`];
+        return [`pyenv shell ${interpreter.envName.toCommandArgumentForPythonExt()}`];
     }
 }