Show the snake icon on extension-created Python terminal REPLs (#26141)

<img width="2113" height="494" alt="image"
src="https://github.com/user-attachments/assets/7dc82d66-60ca-43e8-9cc1-9d3fa44e1a25"
/>

Fixes #21996

Terminal REPLs launched by the extension only set a title, so VS Code
fell back to the default shell/profile icon. This threads an optional
`iconPath` through the terminal creation pipeline and sets
`ThemeIcon('snake')` for the REPL only.

### Changes

- **`common/terminal/types.ts`**: `TerminalCreationOptions` gains
`iconPath?: TerminalOptions['iconPath']`, keeping the internal type
aligned with the VS Code API.
- **`common/terminal/service.ts`**: `ensureTerminal` forwards `iconPath`
on both creation paths — `ensureTerminalLegacy(...)` (env extension,
whose options extend `TerminalOptions`) and
`terminalManager.createTerminal(...)`.
- **`terminals/codeExecution/terminalCodeExecution.ts`**: new `protected
terminalIcon?: TerminalOptions['iconPath']`, passed to
`terminalServiceFactory.getTerminalService(...)` alongside the title.
- **`terminals/codeExecution/repl.ts`**: sets the icon, so plain Python
terminals, Django shells, native REPL tabs, and user-typed `python`
sessions are untouched.

```ts
// repl.ts
this.terminalTitle = 'REPL';
this.terminalIcon = new ThemeIcon('snake');
```

### Tests

- `terminalCodeExec.unit.test.ts`: the title matcher now also asserts
the expected icon id per suite — `snake` for `ReplProvider`, none for
the Terminal and Django providers.
- `service.unit.test.ts`: two tests assert `iconPath` reaches
`terminalManager.createTerminal(...)` and, with `useEnvExtension()`
stubbed on, `ensureTerminalLegacy(...)`.

The env-extension test stubs `ensureTerminalLegacy` with a plain object
rather than a TypeMoq mock: dynamic mocks answer any property access, so
`await`ing one hangs on the phantom `then`.

---------

Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com>
Co-authored-by: edvilme <5952839+edvilme@users.noreply.github.com>

Author: Copilot

src/client/common/terminal/service.ts

@@ -219,13 +219,15 @@ export class TerminalService implements ITerminalService, Disposable {
             this.terminal = await ensureTerminalLegacy(this.options?.resource, {
                 name: this.options?.title || 'Python',
                 hideFromUser: this.options?.hideFromUser,
+                iconPath: this.options?.iconPath,
             });
             return;
         } else {
             this.terminalShellType = this.terminalHelper.identifyTerminalShell(this.terminal);
             this.terminal = this.terminalManager.createTerminal({
                 name: this.options?.title || 'Python',
                 hideFromUser: this.options?.hideFromUser,
+                iconPath: this.options?.iconPath,
             });
             this.terminalAutoActivator.disableAutoActivation(this.terminal);
 

src/client/common/terminal/types.ts

@@ -3,7 +3,7 @@
 
 'use strict';
 
-import { CancellationToken, Event, Terminal, Uri, TerminalShellExecution } from 'vscode';
+import { CancellationToken, Event, Terminal, TerminalOptions, Uri, TerminalShellExecution } from 'vscode';
 import { PythonEnvironment } from '../../pythonEnvironments/info';
 import { IEventNamePropertyMapping } from '../../telemetry/index';
 import { IDisposable, Resource } from '../types';
@@ -65,6 +65,10 @@ export type TerminalCreationOptions = {
      * Object with environment variables that will be added to the Terminal.
      */
     env?: { [key: string]: string | null };
+    /**
+     * Icon displayed for the terminal.
+     */
+    iconPath?: TerminalOptions['iconPath'];
     /**
      * Resource identifier. E.g. used to determine python interpreter that needs to be used or environment variables or the like.
      *

src/client/terminals/codeExecution/djangoShellCodeExecution.ts

@@ -46,6 +46,8 @@ export class DjangoShellCodeExecutionProvider extends TerminalCodeExecutionProvi
             applicationShell,
         );
         this.terminalTitle = 'Django Shell';
+        // The snake icon is reserved for the Python REPL terminal.
+        this.terminalIcon = undefined;
         disposableRegistry.push(new DjangoContextInitializer(documentManager, workspace, fileSystem, commandManager));
     }
 

src/client/terminals/codeExecution/repl.ts

@@ -4,7 +4,7 @@
 'use strict';
 
 import { inject, injectable } from 'inversify';
-import { Disposable } from 'vscode';
+import { Disposable, ThemeIcon } from 'vscode';
 import { IApplicationShell, ICommandManager, IWorkspaceService } from '../../common/application/types';
 import { IPlatformService } from '../../common/platform/types';
 import { ITerminalServiceFactory } from '../../common/terminal/types';
@@ -35,5 +35,6 @@ export class ReplProvider extends TerminalCodeExecutionProvider {
             applicationShell,
         );
         this.terminalTitle = 'REPL';
+        this.terminalIcon = new ThemeIcon('snake');
     }
 }

src/client/terminals/codeExecution/terminalCodeExecution.ts

@@ -5,7 +5,7 @@
 
 import { inject, injectable } from 'inversify';
 import * as path from 'path';
-import { Disposable, Uri } from 'vscode';
+import { Disposable, TerminalOptions, Uri } from 'vscode';
 import { IApplicationShell, ICommandManager, IWorkspaceService } from '../../common/application/types';
 import '../../common/extensions';
 import { IPlatformService } from '../../common/platform/types';
@@ -24,6 +24,7 @@ import { sendTelemetryEvent } from '../../telemetry';
 export class TerminalCodeExecutionProvider implements ICodeExecutionService {
     private hasRanOutsideCurrentDrive = false;
     protected terminalTitle!: string;
+    protected terminalIcon?: TerminalOptions['iconPath'];
     private replActive?: Promise<boolean>;
 
     constructor(
@@ -128,6 +129,7 @@ export class TerminalCodeExecutionProvider implements ICodeExecutionService {
         return this.terminalServiceFactory.getTerminalService({
             resource,
             title: this.terminalTitle,
+            iconPath: this.terminalIcon,
             newTerminalPerFile: options?.newTerminalPerFile,
         });
     }

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

@@ -1,7 +1,7 @@
 // Copyright (c) Microsoft Corporation. All rights reserved.
 // Licensed under the MIT License.
 
-import { expect } from 'chai';
+import { assert, expect } from 'chai';
 import * as path from 'path';
 import * as sinon from 'sinon';
 import * as TypeMoq from 'typemoq';
@@ -11,6 +11,7 @@ import {
     TerminalShellExecution,
     TerminalShellExecutionEndEvent,
     TerminalShellIntegration,
+    ThemeIcon,
     Uri,
     Terminal as VSCodeTerminal,
     WorkspaceConfiguration,
@@ -29,10 +30,12 @@ import {
 import { IDisposableRegistry } from '../../../client/common/types';
 import { IServiceContainer } from '../../../client/ioc/types';
 import { ITerminalAutoActivation } from '../../../client/terminals/types';
+import { noop } from '../../../client/common/utils/misc';
 import { createPythonInterpreter } from '../../utils/interpreters';
 import * as workspaceApis from '../../../client/common/vscodeApis/workspaceApis';
 import * as platform from '../../../client/common/utils/platform';
 import * as extapi from '../../../client/envExt/api.internal';
+import * as extapiLegacy from '../../../client/envExt/api.legacy';
 import { IInterpreterService } from '../../../client/interpreter/contracts';
 import { PythonEnvironment } from '../../../client/pythonEnvironments/info';
 
@@ -55,6 +58,7 @@ suite('Terminal Service', () => {
     let editorConfig: TypeMoq.IMock<WorkspaceConfiguration>;
     let isWindowsStub: sinon.SinonStub;
     let useEnvExtensionStub: sinon.SinonStub;
+    let ensureTerminalLegacyStub: sinon.SinonStub;
     let interpreterService: TypeMoq.IMock<IInterpreterService>;
     let options: TypeMoq.IMock<TerminalCreationOptions>;
     let applicationShell: TypeMoq.IMock<IApplicationShell>;
@@ -64,6 +68,7 @@ suite('Terminal Service', () => {
     setup(() => {
         useEnvExtensionStub = sinon.stub(extapi, 'useEnvExtension');
         useEnvExtensionStub.returns(false);
+        ensureTerminalLegacyStub = sinon.stub(extapiLegacy, 'ensureTerminalLegacy');
 
         terminal = TypeMoq.Mock.ofType<VSCodeTerminal>();
         terminalShellIntegration = TypeMoq.Mock.ofType<TerminalShellIntegration>();
@@ -394,6 +399,36 @@ suite('Terminal Service', () => {
         terminal.verify((t) => t.show(TypeMoq.It.isValue(true)), TypeMoq.Times.never());
     });
 
+    test('Ensure `iconPath` option is forwarded to the created terminal', async () => {
+        terminalHelper
+            .setup((helper) => helper.getEnvironmentActivationCommands(TypeMoq.It.isAny(), TypeMoq.It.isAny()))
+            .returns(() => Promise.resolve(undefined));
+        const iconPath = new ThemeIcon('snake');
+        service = new TerminalService(mockServiceContainer.object, { iconPath });
+        terminalHelper.setup((h) => h.identifyTerminalShell(TypeMoq.It.isAny())).returns(() => TerminalShellType.bash);
+        terminalManager.setup((t) => t.createTerminal(TypeMoq.It.isAny())).returns(() => terminal.object);
+
+        await service.show();
+
+        terminalManager.verify(
+            (t) => t.createTerminal(TypeMoq.It.isObjectWith({ iconPath })),
+            TypeMoq.Times.atLeastOnce(),
+        );
+    });
+
+    test('Ensure `iconPath` option is forwarded when the environments extension is used', async () => {
+        useEnvExtensionStub.returns(true);
+        const iconPath = new ThemeIcon('snake');
+        const createdTerminal = ({ show: noop, dispose: noop } as unknown) as VSCodeTerminal;
+        ensureTerminalLegacyStub.resolves(createdTerminal);
+        service = new TerminalService(mockServiceContainer.object, { iconPath });
+
+        await service.show();
+
+        assert.ok(ensureTerminalLegacyStub.calledOnce);
+        assert.strictEqual(ensureTerminalLegacyStub.firstCall.args[1].iconPath, iconPath);
+    });
+
     test('Ensure terminal shown otherwise', async () => {
         terminalHelper
             .setup((helper) => helper.getEnvironmentActivationCommands(TypeMoq.It.isAny(), TypeMoq.It.isAny()))

src/test/terminals/codeExecution/terminalCodeExec.unit.test.ts

@@ -5,7 +5,7 @@ import { expect } from 'chai';
 import * as path from 'path';
 import { SemVer } from 'semver';
 import * as TypeMoq from 'typemoq';
-import { Disposable, Uri, WorkspaceFolder } from 'vscode';
+import { Disposable, ThemeIcon, Uri, WorkspaceFolder } from 'vscode';
 import {
     IApplicationShell,
     ICommandManager,
@@ -45,6 +45,7 @@ suite('Terminal - Code Execution', () => {
         let disposables: Disposable[] = [];
         let executor: ICodeExecutionService;
         let expectedTerminalTitle: string | undefined;
+        let expectedTerminalIconId: string | undefined;
         let terminalFactory: TypeMoq.IMock<ITerminalServiceFactory>;
         let documentManager: TypeMoq.IMock<IDocumentManager>;
         let commandManager: TypeMoq.IMock<ICommandManager>;
@@ -81,7 +82,6 @@ suite('Terminal - Code Execution', () => {
             settings = TypeMoq.Mock.ofType<IPythonSettings>();
             settings.setup((s) => s.terminal).returns(() => terminalSettings.object);
             configService.setup((c) => c.getSettings(TypeMoq.It.isAny())).returns(() => settings.object);
-
             switch (testSuiteName) {
                 case 'Terminal Execution': {
                     executor = new TerminalCodeExecutionProvider(
@@ -108,6 +108,7 @@ suite('Terminal - Code Execution', () => {
                         applicationShell.object,
                     );
                     expectedTerminalTitle = 'REPL';
+                    expectedTerminalIconId = 'snake';
                     break;
                 }
                 case 'Django Execution': {
@@ -132,6 +133,7 @@ suite('Terminal - Code Execution', () => {
                         applicationShell.object,
                     );
                     expectedTerminalTitle = 'Django Shell';
+                    expectedTerminalIconId = undefined;
                     break;
                 }
                 default: {
@@ -145,7 +147,12 @@ suite('Terminal - Code Execution', () => {
                 terminalFactory
                     .setup((f) =>
                         f.getTerminalService(
-                            TypeMoq.It.is<TerminalCreationOptions>((a) => a.title === expectedTerminalTitle),
+                            TypeMoq.It.is<TerminalCreationOptions>(
+                                (a) =>
+                                    a.title === expectedTerminalTitle &&
+                                    (a.iconPath instanceof ThemeIcon ? a.iconPath.id : undefined) ===
+                                        expectedTerminalIconId,
+                            ),
                         ),
                     )
                     .returns(() => terminalService.object);