Add code execution support via env extension

Author: karthiknadig

src/client/common/terminal/service.ts

@@ -21,6 +21,9 @@ import {
 } from './types';
 import { traceVerbose } from '../../logging';
 import { getConfiguration } from '../vscodeApis/workspaceApis';
+import { useEnvExtension } from '../../envExt/api.internal';
+import { ensureTerminalLegacy } from '../../envExt/api.legacy';
+import { sleep } from '../utils/async';
 import { isWindows } from '../utils/platform';
 
 @injectable()
@@ -132,22 +135,29 @@ export class TerminalService implements ITerminalService, Disposable {
         if (this.terminal) {
             return;
         }
-        this.terminalShellType = this.terminalHelper.identifyTerminalShell(this.terminal);
-        this.terminal = this.terminalManager.createTerminal({
-            name: this.options?.title || 'Python',
-            hideFromUser: this.options?.hideFromUser,
-        });
-        this.terminalAutoActivator.disableAutoActivation(this.terminal);
 
-        // Sometimes the terminal takes some time to start up before it can start accepting input.
-        await new Promise((resolve) => setTimeout(resolve, 100));
+        if (useEnvExtension()) {
+            this.terminal = await ensureTerminalLegacy(this.options?.resource, {
+                name: this.options?.title || 'Python',
+                hideFromUser: this.options?.hideFromUser,
+            });
+        } else {
+            this.terminalShellType = this.terminalHelper.identifyTerminalShell(this.terminal);
+            this.terminal = this.terminalManager.createTerminal({
+                name: this.options?.title || 'Python',
+                hideFromUser: this.options?.hideFromUser,
+            });
+            this.terminalAutoActivator.disableAutoActivation(this.terminal);
+
+            await sleep(100);
 
-        await this.terminalActivator.activateEnvironmentInTerminal(this.terminal, {
-            resource: this.options?.resource,
-            preserveFocus,
-            interpreter: this.options?.interpreter,
-            hideFromUser: this.options?.hideFromUser,
-        });
+            await this.terminalActivator.activateEnvironmentInTerminal(this.terminal, {
+                resource: this.options?.resource,
+                preserveFocus,
+                interpreter: this.options?.interpreter,
+                hideFromUser: this.options?.hideFromUser,
+            });
+        }
 
         if (!this.options?.hideFromUser) {
             this.terminal.show(preserveFocus);

src/client/envExt/api.internal.ts

@@ -77,7 +77,7 @@ export async function runInTerminal(
             show,
         });
     }
-    throw new Error('Python environment not found');
+    throw new Error('Invalid arguments to run in terminal');
 }
 
 export async function runInDedicatedTerminal(
@@ -89,12 +89,12 @@ export async function runInDedicatedTerminal(
     const envExtApi = await getEnvExtApi();
     const env = await getEnvironment(resource);
     const project = resource ? envExtApi.getPythonProject(resource) : undefined;
-    if (env && project && resource) {
-        return envExtApi.runInDedicatedTerminal(resource, env, {
+    if (env && project) {
+        return envExtApi.runInDedicatedTerminal(resource ?? 'global', env, {
             cwd: cwd ?? project.uri,
             args,
             show,
         });
     }
-    throw new Error('Python environment not found');
+    throw new Error('Invalid arguments to run in dedicated terminal');
 }

src/client/envExt/api.legacy.ts

@@ -1,10 +1,10 @@
 // Copyright (c) Microsoft Corporation. All rights reserved.
 // Licensed under the MIT License.
 
-import { Uri } from 'vscode';
+import { Terminal, Uri } from 'vscode';
 import { getEnvExtApi, getEnvironment } from './api.internal';
 import { EnvironmentType, PythonEnvironment as PythonEnvironmentLegacy } from '../pythonEnvironments/info';
-import { PythonEnvironment } from './types';
+import { PythonEnvironment, PythonTerminalOptions } from './types';
 import { Architecture } from '../common/utils/platform';
 import { parseVersion } from '../pythonEnvironments/base/info/pythonVersion';
 import { PythonEnvType } from '../pythonEnvironments/base/info';
@@ -149,3 +149,19 @@ export async function resetInterpreterLegacy(uri: Uri | undefined): Promise<void
     const api = await getEnvExtApi();
     await api.setEnvironment(uri, undefined);
 }
+
+export async function ensureTerminalLegacy(
+    resource: Uri | undefined,
+    options?: PythonTerminalOptions,
+): Promise<Terminal> {
+    const api = await getEnvExtApi();
+    const pythonEnv = await api.getEnvironment(resource);
+    const project = resource ? api.getPythonProject(resource) : undefined;
+
+    if (pythonEnv && project) {
+        const fixedOptions = options ? { ...options } : { cwd: project.uri };
+        const terminal = await api.createTerminal(pythonEnv, fixedOptions);
+        return terminal;
+    }
+    throw new Error('Invalid arguments to create terminal');
+}

src/client/envExt/types.ts

@@ -1,7 +1,17 @@
 // Copyright (c) Microsoft Corporation. All rights reserved.
 // Licensed under the MIT License.
 
-import { Uri, Disposable, MarkdownString, Event, LogOutputChannel, ThemeIcon, Terminal, TaskExecution } from 'vscode';
+import {
+    Uri,
+    Disposable,
+    MarkdownString,
+    Event,
+    LogOutputChannel,
+    ThemeIcon,
+    Terminal,
+    TaskExecution,
+    TerminalOptions,
+} from 'vscode';
 
 /**
  * The path to an icon, or a theme-specific configuration of icons.
@@ -243,7 +253,7 @@ export type DidChangeEnvironmentEventArgs = {
     /**
      * The URI of the environment that changed.
      */
-    readonly uri: Uri;
+    readonly uri: Uri | undefined;
 
     /**
      * The old Python environment before the change.
@@ -1030,25 +1040,27 @@ export interface PythonProjectModifyApi {
  */
 export interface PythonProjectApi extends PythonProjectCreationApi, PythonProjectGetterApi, PythonProjectModifyApi {}
 
+export interface PythonTerminalOptions extends TerminalOptions {
+    /**
+     * Whether to show the terminal.
+     */
+    disableActivation?: boolean;
+}
+
 export interface PythonTerminalCreateApi {
-    createTerminal(
-        environment: PythonEnvironment,
-        cwd: string | Uri,
-        envVars?: { [key: string]: string | undefined },
-    ): Promise<Terminal>;
+    createTerminal(environment: PythonEnvironment, options: PythonTerminalOptions): Promise<Terminal>;
 }
 
 export interface PythonTerminalExecutionOptions {
     cwd: string | Uri;
     args?: string[];
-
     show?: boolean;
 }
 
 export interface PythonTerminalRunApi {
     runInTerminal(environment: PythonEnvironment, options: PythonTerminalExecutionOptions): Promise<Terminal>;
     runInDedicatedTerminal(
-        terminalKey: Uri,
+        terminalKey: Uri | string,
         environment: PythonEnvironment,
         options: PythonTerminalExecutionOptions,
     ): Promise<Terminal>;

src/client/terminals/codeExecution/codeExecutionManager.ts

@@ -192,7 +192,7 @@ export class CodeExecutionManager implements ICodeExecutionManager {
             return;
         }
         const codeExecutionHelper = this.serviceContainer.get<ICodeExecutionHelper>(ICodeExecutionHelper);
-        const codeToExecute = await codeExecutionHelper.getSelectedTextToExecute(activeEditor!);
+        const codeToExecute = await codeExecutionHelper.getSelectedTextToExecute(activeEditor);
         let wholeFileContent = '';
         if (activeEditor && activeEditor.document) {
             wholeFileContent = activeEditor.document.getText();
@@ -214,7 +214,7 @@ export class CodeExecutionManager implements ICodeExecutionManager {
             noop();
         }
 
-        await executionService.execute(normalizedCode, activeEditor!.document.uri);
+        await executionService.execute(normalizedCode, activeEditor.document.uri);
     }
 
     private shouldTerminalFocusOnStart(uri: Uri | undefined): boolean {