fix(vscode): force dmypy executable override

v0.4.18

The jemalloc allocator now owns mypy.dmypyExecutable: it
unconditionally overrides any pre-existing value (custom or
carried over from before install) so the venv-pinned dmypy is
always used. Drops the previous "leave user override in place"
guard and the now-dead isDefaultDmypyValue helper.

CMK-36081

Change-Id: Iecd329f2085c1b0f338d5c48679dd2e909a0af52

Author: otAAAh

.ide/vscode/changelog/v0.4.18.md

@@ -0,0 +1,3 @@
+## v0.4.18
+
+- **fix**: force dmypy executable override (CMK-36081)

.ide/vscode/package.json

@@ -2,7 +2,7 @@
   "name": "cmk-vscode",
   "displayName": "CMK Dev Tools for VS Code",
   "description": "Build commands and helpers for Checkmk development",
-  "version": "0.4.17",
+  "version": "0.4.18",
   "publisher": "checkmk",
   "engines": {
     "vscode": "^1.85.0"

.ide/vscode/src/profiles/python/jemallocAllocator.ts

@@ -7,7 +7,6 @@ import * as fs from 'fs'
 import * as path from 'path'
 import * as vscode from 'vscode'
 
-import { resolveVariables } from '../../core/config'
 import { error, log, notifyError, notifyInfo, notifyWarn } from '../../core/log'
 import { safeExecAsync } from '../../core/shell'
 import { killAllDmypyDaemons } from './mypyConfig'
@@ -170,24 +169,6 @@ function defaultDmypyPath(wsFolder: vscode.WorkspaceFolder): string {
   return path.join(wsFolder.uri.fsPath, '.venv', 'bin', 'dmypy')
 }
 
-/** Decide whether a `mypy.dmypyExecutable` value is one of the Checkmk
- *  default forms (and therefore safe to take over when switching to jemalloc
- *  mode), versus a user-managed custom path we should leave alone.
- *
- *  Accepted forms:
- *    - `${cmk-ext:workspaceFolder}/.venv/bin/dmypy` — current Checkmk bundled default.
- *    - `${workspaceFolder}/.venv/bin/dmypy` — legacy form still present in
- *      existing `.code-workspace` files from before the switch to `cmk-ext:`.
- *    - `<workspace>/.venv/bin/dmypy` — the resolved absolute path written
- *      after `resolveVariables` expands the bundled default.
- *  We compare strings only; we do not re-expand VS Code's native variables. */
-export function isDefaultDmypyValue(value: string, wsFolder: vscode.WorkspaceFolder): boolean {
-  const resolvedByExt = resolveVariables(value) as string
-  return (
-    resolvedByExt === defaultDmypyPath(wsFolder) || value === '${workspaceFolder}/.venv/bin/dmypy'
-  )
-}
-
 function readAllocatorMode(): AllocatorMode {
   const v = vscode.workspace.getConfiguration().get<string>(SETTING_ALLOCATOR, 'default')
   return v === 'jemalloc' ? 'jemalloc' : 'default'
@@ -277,48 +258,35 @@ function deleteWrapperIfPresent(wrapperPath: string): void {
 /** Reconcile `mypy.dmypyExecutable` to match `cmk.mypy.allocator`. Idempotent.
  *  - `"jemalloc"` + probe hit → write wrapper, point dmypyExecutable at it.
  *  - `"jemalloc"` + probe miss → notify once, leave setting armed.
- *  - `"default"` → release ownership (unset dmypyExecutable if it's ours),
- *    delete wrapper.
- *  Never overwrites a manual `mypy.dmypyExecutable` override — if the current
- *  value is neither unset nor our own wrapper path, we log and skip. */
+ *  - `"default"` → restore the bundled venv default, delete wrapper.
+ *  The extension owns `mypy.dmypyExecutable`: it unconditionally overrides any
+ *  pre-existing value (including a custom path or one carried over from before
+ *  the extension was installed) so the venv-pinned dmypy is always used. */
 export async function applyAllocatorSetting(
   context: vscode.ExtensionContext,
   wsFolder: vscode.WorkspaceFolder
 ): Promise<void> {
   const wrapperPath = wrapperPathFor(context)
   const mode = readAllocatorMode()
   const current = readCurrentDmypyExecutable(wsFolder)
-  const weOwn =
-    current === undefined || current === wrapperPath || isDefaultDmypyValue(current, wsFolder)
 
   if (mode === 'default') {
     // Restore the bundled defaults instead of leaving the keys unset — matangover
     // falls back to `python -m mypy.dmypy` when `mypy.dmypyExecutable` is empty,
-    // which breaks the venv-pinned setup. Only overwrite when we owned the prior
-    // value (our wrapper, the bundled default literal, or unset) — never clobber
-    // a custom user-managed dmypy path.
-    if (weOwn) {
-      const previousDmypy = current
-      const previousRun = vscode.workspace
-        .getConfiguration('mypy', wsFolder)
-        .get<boolean>(RUN_USING_INTERPRETER_SETTING)
-      await updateDmypyExecutable(wsFolder, defaultDmypyPath(wsFolder))
-      await updateRunUsingInterpreter(wsFolder, true)
-      log(
-        `cmk.mypy.allocator=default — restored mypy.dmypyExecutable=${defaultDmypyPath(wsFolder)}, runUsingActiveInterpreter=true`
-      )
-      if (previousDmypy === wrapperPath || previousRun === false) {
-        await killAllDmypyDaemons()
-      }
-    }
-    deleteWrapperIfPresent(wrapperPath)
-    return
-  }
-
-  if (!weOwn) {
+    // which breaks the venv-pinned setup.
+    const target = defaultDmypyPath(wsFolder)
+    const previousRun = vscode.workspace
+      .getConfiguration('mypy', wsFolder)
+      .get<boolean>(RUN_USING_INTERPRETER_SETTING)
+    if (current !== target) await updateDmypyExecutable(wsFolder, target)
+    if (previousRun !== true) await updateRunUsingInterpreter(wsFolder, true)
     log(
-      `cmk.mypy.allocator=jemalloc but mypy.dmypyExecutable is set to a custom path (${current}) — leaving user override in place`
+      `cmk.mypy.allocator=default — set mypy.dmypyExecutable=${target}, runUsingActiveInterpreter=true`
     )
+    if (current === wrapperPath || previousRun === false) {
+      await killAllDmypyDaemons()
+    }
+    deleteWrapperIfPresent(wrapperPath)
     return
   }
 

.ide/vscode/tests/profiles/python/jemallocAllocator.test.ts

@@ -129,43 +129,6 @@ describe('detectJemallocPathAsync', () => {
   })
 })
 
-describe('isDefaultDmypyValue', () => {
-  const wsFolder = { uri: { fsPath: '/ws' } } as never
-
-  beforeEach(() => {
-    vi.resetModules()
-  })
-  afterEach(() => {
-    vi.doUnmock('../../../src/core/config')
-  })
-
-  it('returns true for the cmk-ext placeholder form', async () => {
-    vi.doMock('../../../src/core/config', () => ({
-      resolveVariables: (v: string) => v.replace('${cmk-ext:workspaceFolder}', '/ws')
-    }))
-    const { isDefaultDmypyValue } = await import('../../../src/profiles/python/jemallocAllocator')
-    expect(isDefaultDmypyValue('${cmk-ext:workspaceFolder}/.venv/bin/dmypy', wsFolder)).toBe(true)
-  })
-
-  it('returns true for the resolved absolute default', async () => {
-    vi.doMock('../../../src/core/config', () => ({ resolveVariables: (v: string) => v }))
-    const { isDefaultDmypyValue } = await import('../../../src/profiles/python/jemallocAllocator')
-    expect(isDefaultDmypyValue('/ws/.venv/bin/dmypy', wsFolder)).toBe(true)
-  })
-
-  it('returns true for the legacy ${workspaceFolder} form (still present in older .code-workspace files)', async () => {
-    vi.doMock('../../../src/core/config', () => ({ resolveVariables: (v: string) => v }))
-    const { isDefaultDmypyValue } = await import('../../../src/profiles/python/jemallocAllocator')
-    expect(isDefaultDmypyValue('${workspaceFolder}/.venv/bin/dmypy', wsFolder)).toBe(true)
-  })
-
-  it('returns false for an unrelated custom path', async () => {
-    vi.doMock('../../../src/core/config', () => ({ resolveVariables: (v: string) => v }))
-    const { isDefaultDmypyValue } = await import('../../../src/profiles/python/jemallocAllocator')
-    expect(isDefaultDmypyValue('/opt/custom/dmypy', wsFolder)).toBe(false)
-  })
-})
-
 describe('installCommandForPlatformAsync', () => {
   beforeEach(() => {
     vi.resetModules()