Prompt Native REPL in Terminal

src/client/common/utils/localize.ts

@@ -101,6 +101,10 @@ export namespace AttachProcess {
 
 export namespace Repl {
     export const disableSmartSend = l10n.t('Disable Smart Send');
+    // TODO: get feedback on text message below:
+    export const terminalSuggestNativeReplPrompt = l10n.t(
+        'The Python extension now includes an editor based native Python REPL with Intellisense, syntax highlighting. Would you like to try this out?',
+    );
 }
 export namespace Pylance {
     export const remindMeLater = l10n.t('Remind me later');

src/client/extensionActivation.ts

@@ -111,7 +111,7 @@ export function activateFeatures(ext: ExtensionState, _components: Components):
     );
     const executionHelper = ext.legacyIOC.serviceContainer.get<ICodeExecutionHelper>(ICodeExecutionHelper);
     const commandManager = ext.legacyIOC.serviceContainer.get<ICommandManager>(ICommandManager);
-    registerTriggerForTerminalREPL(ext.disposables);
+    registerTriggerForTerminalREPL(commandManager, ext.disposables);
     registerStartNativeReplCommand(ext.disposables, interpreterService);
     registerReplCommands(ext.disposables, interpreterService, executionHelper, commandManager);
     registerReplExecuteOnEnter(ext.disposables, interpreterService, commandManager);

src/client/terminals/codeExecution/terminalCodeExecution.ts

@@ -5,20 +5,23 @@
 
 import { inject, injectable } from 'inversify';
 import * as path from 'path';
-import { Disposable, Uri } from 'vscode';
+import { Disposable, TerminalShellExecutionStartEvent, Uri } from 'vscode';
 import { IApplicationShell, ICommandManager, IWorkspaceService } from '../../common/application/types';
 import '../../common/extensions';
 import { IPlatformService } from '../../common/platform/types';
 import { ITerminalService, ITerminalServiceFactory } from '../../common/terminal/types';
 import { IConfigurationService, IDisposable, IDisposableRegistry, Resource } from '../../common/types';
-import { Diagnostics, Repl } from '../../common/utils/localize';
-import { showWarningMessage } from '../../common/vscodeApis/windowApis';
+import { Common, Diagnostics, Repl } from '../../common/utils/localize';
+import { onDidStartTerminalShellExecution, showWarningMessage } from '../../common/vscodeApis/windowApis';
 import { IInterpreterService } from '../../interpreter/contracts';
 import { traceInfo } from '../../logging';
 import { buildPythonExecInfo, PythonExecInfo } from '../../pythonEnvironments/exec';
 import { ICodeExecutionService } from '../../terminals/types';
 import { EventName } from '../../telemetry/constants';
 import { sendTelemetryEvent } from '../../telemetry';
+import { getActiveInterpreter } from '../../repl/replUtils';
+import { getNativeRepl } from '../../repl/nativeRepl';
+import { checkREPLCommand } from './terminalReplWatcher';
 
 @injectable()
 export class TerminalCodeExecutionProvider implements ICodeExecutionService {
@@ -63,11 +66,43 @@ export class TerminalCodeExecutionProvider implements ICodeExecutionService {
         }
     }
 
+    public suggestNativeRepl(resource: Resource) {
+        this.disposables.push(
+            onDidStartTerminalShellExecution(async (e: TerminalShellExecutionStartEvent) => {
+                if (e.execution.commandLine.isTrusted && checkREPLCommand(e.execution.commandLine.value)) {
+                    sendTelemetryEvent(EventName.REPL, undefined, { replType: 'manualTerminal' });
+                    const selection = await showWarningMessage(
+                        Repl.terminalSuggestNativeReplPrompt,
+                        Common.doNotShowAgain,
+                    );
+                    if (selection === Repl.terminalSuggestNativeReplPrompt) {
+                        sendTelemetryEvent(EventName.REPL, undefined, { replType: 'Native' });
+                        const interpreter = await getActiveInterpreter(resource as Uri, this.interpreterService);
+                        if (interpreter) {
+                            const nativeRepl = await getNativeRepl(interpreter, this.disposables);
+                            await nativeRepl.sendToNativeRepl(undefined, false);
+                        }
+                    }
+                }
+            }),
+        );
+    }
+
     public async initializeRepl(resource: Resource) {
         const terminalService = this.getTerminalService(resource);
+        if (!this.replActive) {
+            this.suggestNativeRepl(resource);
+        }
         if (this.replActive && (await this.replActive)) {
             await terminalService.show();
             return;
+        } else {
+            // Suggest launch of Native REPL
+            const interpreter = await getActiveInterpreter(resource!, this.interpreterService);
+            if (interpreter) {
+                const nativeRepl = await getNativeRepl(interpreter, this.disposables);
+                await nativeRepl.sendToNativeRepl(undefined, false);
+            }
         }
         sendTelemetryEvent(EventName.REPL, undefined, { replType: 'Terminal' });
         this.replActive = new Promise<boolean>(async (resolve) => {

src/client/terminals/codeExecution/terminalReplWatcher.ts

@@ -2,17 +2,29 @@ import { Disposable, TerminalShellExecutionStartEvent } from 'vscode';
 import { onDidStartTerminalShellExecution } from '../../common/vscodeApis/windowApis';
 import { sendTelemetryEvent } from '../../telemetry';
 import { EventName } from '../../telemetry/constants';
+import { ICommandManager } from '../../common/application/types';
+import { Commands } from '../../common/constants';
 
-function checkREPLCommand(command: string): boolean {
+export function checkREPLCommand(command: string): boolean {
     const lower = command.toLowerCase().trimStart();
     return lower.startsWith('python') || lower.startsWith('py ');
 }
 
-export function registerTriggerForTerminalREPL(disposables: Disposable[]): void {
+export async function registerTriggerForTerminalREPL(
+    commandManager: ICommandManager,
+    disposables: Disposable[],
+): Promise<void> {
     disposables.push(
         onDidStartTerminalShellExecution(async (e: TerminalShellExecutionStartEvent) => {
             if (e.execution.commandLine.isTrusted && checkREPLCommand(e.execution.commandLine.value)) {
                 sendTelemetryEvent(EventName.REPL, undefined, { replType: 'manualTerminal' });
+                // TODO: Prompt user to start Native REPL
+
+                // If yes, then launch native REPL
+                await commandManager.executeCommand(Commands.Start_Native_REPL, undefined);
+
+                // TODO: Decide whether we want everytime, or once per workspace, or once per terminal
+                // How do I even track all terminal instances.
             }
         }),
     );