Add more approach, to make experience faster

Author: anthonykim1

src/client/common/application/terminalManager.ts

@@ -38,6 +38,9 @@ export class TerminalManager implements ITerminalManager {
     public onDidEndTerminalShellExecution(handler: (e: TerminalShellExecutionEndEvent) => void): Disposable {
         return window.onDidEndTerminalShellExecution(handler);
     }
+    public onDidChangeTerminalState(handler: (e: Terminal) => void): Disposable {
+        return window.onDidChangeTerminalState(handler);
+    }
 }
 
 /**

src/client/common/application/types.ts

@@ -939,6 +939,8 @@ export interface ITerminalManager {
     onDidChangeTerminalShellIntegration(handler: (e: TerminalShellIntegrationChangeEvent) => void): Disposable;
 
     onDidEndTerminalShellExecution(handler: (e: TerminalShellExecutionEndEvent) => void): Disposable;
+
+    onDidChangeTerminalState(handler: (e: Terminal) => void): Disposable;
 }
 
 export const IDebugService = Symbol('IDebugManager');

src/client/common/terminal/service.ts

@@ -38,7 +38,8 @@ export class TerminalService implements ITerminalService, Disposable {
     private _terminalFirstLaunched: boolean = true;
     private pythonReplCommandQueue: string[] = [];
     private isReplReady: boolean = false;
-    private replDataListener?: Disposable;
+    private replPromptListener?: Disposable;
+    private replShellTypeListener?: Disposable;
     public get onDidCloseTerminal(): Event<void> {
         return this.terminalClosed.event.bind(this.terminalClosed);
     }
@@ -105,28 +106,48 @@ export class TerminalService implements ITerminalService, Disposable {
     }
 
     private startReplListener(): void {
-        if (this.replDataListener) {
+        if (this.replPromptListener || this.replShellTypeListener) {
             return;
         }
 
+        this.replShellTypeListener = this.terminalManager.onDidChangeTerminalState((terminal) => {
+            if (this.terminal && terminal === this.terminal) {
+                if (terminal.state.shell == 'python') {
+                    traceVerbose('Python REPL ready from terminal shell api');
+                    this.onReplReady();
+                }
+            }
+        });
+
         let terminalData = '';
-        this.replDataListener = this.applicationShell.onDidWriteTerminalData((e) => {
+        this.replPromptListener = this.applicationShell.onDidWriteTerminalData((e) => {
             if (this.terminal && e.terminal === this.terminal) {
                 terminalData += e.data;
                 if (/>>>\s*$/.test(terminalData)) {
-                    traceVerbose('Python REPL ready, detected >>> prompt');
-                    this.isReplReady = true;
-                    this.disposeReplListener();
-                    this.flushReplQueue();
+                    traceVerbose('Python REPL ready, from >>> prompt detection');
+                    this.onReplReady();
                 }
             }
         });
     }
 
+    private onReplReady(): void {
+        if (this.isReplReady) {
+            return;
+        }
+        this.isReplReady = true;
+        this.flushReplQueue();
+        this.disposeReplListener();
+    }
+
     private disposeReplListener(): void {
-        if (this.replDataListener) {
-            this.replDataListener.dispose();
-            this.replDataListener = undefined;
+        if (this.replPromptListener) {
+            this.replPromptListener.dispose();
+            this.replPromptListener = undefined;
+        }
+        if (this.replShellTypeListener) {
+            this.replShellTypeListener.dispose();
+            this.replShellTypeListener = undefined;
         }
     }
 

src/client/common/vscodeApis/windowApis.ts

@@ -25,6 +25,7 @@ import {
     NotebookDocument,
     NotebookEditor,
     NotebookDocumentShowOptions,
+    Terminal,
 } from 'vscode';
 import { createDeferred, Deferred } from '../utils/async';
 import { Resource } from '../types';
@@ -124,6 +125,10 @@ export function onDidStartTerminalShellExecution(handler: (e: TerminalShellExecu
     return window.onDidStartTerminalShellExecution(handler);
 }
 
+export function onDidChangeTerminalState(handler: (e: Terminal) => void): Disposable {
+    return window.onDidChangeTerminalState(handler);
+}
+
 export enum MultiStepAction {
     Back = 'Back',
     Cancel = 'Cancel',

src/test/common/terminals/service.unit.test.ts

@@ -59,6 +59,7 @@ suite('Terminal Service', () => {
     let options: TypeMoq.IMock<TerminalCreationOptions>;
     let applicationShell: TypeMoq.IMock<IApplicationShell>;
     let onDidWriteTerminalDataEmitter: EventEmitter<TerminalDataWriteEvent>;
+    let onDidChangeTerminalStateEmitter: EventEmitter<VSCodeTerminal>;
 
     setup(() => {
         useEnvExtensionStub = sinon.stub(extapi, 'useEnvExtension');
@@ -122,12 +123,16 @@ suite('Terminal Service', () => {
         mockServiceContainer.setup((c) => c.get(ITerminalAutoActivation)).returns(() => terminalAutoActivator.object);
         mockServiceContainer.setup((c) => c.get(IInterpreterService)).returns(() => interpreterService.object);
 
-        // Setup IApplicationShell mock with onDidWriteTerminalData
         applicationShell = TypeMoq.Mock.ofType<IApplicationShell>();
         onDidWriteTerminalDataEmitter = new EventEmitter<TerminalDataWriteEvent>();
         applicationShell.setup((a) => a.onDidWriteTerminalData).returns(() => onDidWriteTerminalDataEmitter.event);
         mockServiceContainer.setup((c) => c.get(IApplicationShell)).returns(() => applicationShell.object);
 
+        onDidChangeTerminalStateEmitter = new EventEmitter<VSCodeTerminal>();
+        terminalManager
+            .setup((t) => t.onDidChangeTerminalState(TypeMoq.It.isAny()))
+            .returns((handler) => onDidChangeTerminalStateEmitter.event(handler));
+
         getConfigurationStub = sinon.stub(workspaceApis, 'getConfiguration');
         isWindowsStub = sinon.stub(platform, 'isWindows');
         pythonConfig = TypeMoq.Mock.ofType<WorkspaceConfiguration>();
@@ -352,6 +357,30 @@ suite('Terminal Service', () => {
         terminal.verify((t) => t.sendText(TypeMoq.It.isValue(textToSend)), TypeMoq.Times.exactly(1));
     });
 
+    test('Ensure REPL ready when onDidChangeTerminalState fires with python shell', async () => {
+        pythonConfig
+            .setup((p) => p.get('terminal.shellIntegration.enabled'))
+            .returns(() => false)
+            .verifiable(TypeMoq.Times.once());
+
+        terminalHelper
+            .setup((helper) => helper.getEnvironmentActivationCommands(TypeMoq.It.isAny(), TypeMoq.It.isAny()))
+            .returns(() => Promise.resolve(undefined));
+        service = new TerminalService(mockServiceContainer.object);
+        const textToSend = 'Some Text';
+        terminalHelper.setup((h) => h.identifyTerminalShell(TypeMoq.It.isAny())).returns(() => TerminalShellType.bash);
+
+        terminal.setup((t) => t.state).returns(() => ({ isInteractedWith: true, shell: 'python' }));
+        terminalManager.setup((t) => t.createTerminal(TypeMoq.It.isAny())).returns(() => terminal.object);
+
+        await service.ensureTerminal();
+        const executePromise = service.executeCommand(textToSend, true);
+        onDidChangeTerminalStateEmitter.fire(terminal.object);
+        await executePromise;
+
+        terminal.verify((t) => t.sendText(TypeMoq.It.isValue(textToSend)), TypeMoq.Times.exactly(1));
+    });
+
     test('Ensure terminal is not shown if `hideFromUser` option is set to `true`', async () => {
         terminalHelper
             .setup((helper) => helper.getEnvironmentActivationCommands(TypeMoq.It.isAny(), TypeMoq.It.isAny()))