fix(live-debugger): remove TypeScript suppression comments and fix type safety

Remove @ts-nocheck from all transform files by introducing a local
BabelPath interface that avoids the cross-package type conflict between
@types/babel__traverse's bundled @babel/types and the directly imported
@babel/types. Replace all `any` types and `as` casts with proper type
narrowing. Convert require() calls to ESM imports. Use shared
getContextMock test helper instead of hand-rolled mock. Delete orphaned
rum/src/built/live-debugger-helpers.ts (stubs are already injected via
context.inject in the plugin entry point).

Author: watson

packages/plugins/live-debugger/package.json

@@ -31,8 +31,6 @@
         "magic-string": "0.30.21"
     },
     "devDependencies": {
-        "@types/babel__core": "^7.20.0",
-        "@types/babel__traverse": "^7.20.0",
         "typescript": "5.4.3"
     }
 }

packages/plugins/live-debugger/src/index.test.ts

@@ -1,8 +1,8 @@
+import { getContextMock } from '@dd/tests/_jest/helpers/mocks';
 // Unless explicitly stated otherwise all files in this repository are licensed under the MIT License.
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
-
-import type { GlobalContext } from '@dd/core/types';
+import type { UnpluginBuildContext, UnpluginContext } from 'unplugin';
 
 import { getLiveDebuggerPlugin } from './index';
 import type { LiveDebuggerOptionsWithDefaults } from './types';
@@ -19,20 +19,35 @@ const makeOptions = (
     ...overrides,
 });
 
-const mockContext = {
-    buildRoot: '/',
-    getLogger: () => ({
-        info: jest.fn(),
-        warn: jest.fn(),
-        error: jest.fn(),
-        debug: jest.fn(),
-    }),
-} as unknown as GlobalContext;
-
-function getHandler(options: LiveDebuggerOptionsWithDefaults) {
+const mockContext = getContextMock({ buildRoot: '/' });
+
+const mockBuildContext: UnpluginBuildContext & UnpluginContext = {
+    addWatchFile: jest.fn(),
+    emitFile: jest.fn(),
+    getWatchFiles: jest.fn(() => []),
+    parse: jest.fn(),
+    error: jest.fn(),
+    warn: jest.fn(),
+};
+
+function getHandler(
+    options: LiveDebuggerOptionsWithDefaults,
+): (code: string, id: string) => { code: string } {
     const plugin = getLiveDebuggerPlugin(options, mockContext);
-    return (plugin.transform as { handler: (code: string, id: string) => { code: string } })
-        .handler;
+    const transform = plugin.transform;
+
+    if (typeof transform !== 'object' || transform === null || !('handler' in transform)) {
+        throw new Error('Expected transform to be an ObjectHook with a handler');
+    }
+
+    const { handler } = transform;
+    return (code: string, id: string) => {
+        const result = handler.call(mockBuildContext, code, id);
+        if (typeof result === 'object' && result !== null && 'code' in result) {
+            return { code: result.code };
+        }
+        throw new Error('Unexpected handler result');
+    };
 }
 
 describe('getLiveDebuggerPlugin', () => {

packages/plugins/live-debugger/src/transform/babel-path.types.ts

@@ -0,0 +1,17 @@
+// Unless explicitly stated otherwise all files in this repository are licensed under the MIT License.
+// This product includes software developed at Datadog (https://www.datadoghq.com/).
+// Copyright 2019-Present Datadog, Inc.
+
+import type * as t from '@babel/types';
+
+/**
+ * Minimal NodePath-compatible interface using types exclusively from
+ * `@babel/types`. This avoids the type conflict between
+ * `@types/babel__traverse`'s bundled copy of `@babel/types` and the
+ * directly imported `@babel/types` package.
+ */
+export interface BabelPath<T extends t.Node = t.Node> {
+    node: T;
+    parent: t.Node;
+    parentPath: BabelPath | null;
+}

packages/plugins/live-debugger/src/transform/babel-traverse.d.ts

@@ -0,0 +1,26 @@
+// Unless explicitly stated otherwise all files in this repository are licensed under the MIT License.
+// This product includes software developed at Datadog (https://www.datadoghq.com/).
+// Copyright 2019-Present Datadog, Inc.
+
+/**
+ * Local type declaration for `@babel/traverse` that avoids the structural
+ * incompatibility between `@types/babel__traverse`'s bundled copy of
+ * `@babel/types` and the directly imported `@babel/types` package.
+ *
+ * Only the subset of the API used by this plugin is declared.
+ */
+declare module '@babel/traverse' {
+    import type * as t from '@babel/types';
+
+    import type { BabelPath } from './babel-path.types';
+
+    type VisitorHandler<T extends t.Node> = (path: BabelPath<T>) => void;
+
+    interface Visitor {
+        Function?: VisitorHandler<t.Function>;
+    }
+
+    function traverse(ast: object, visitor: Visitor): void;
+
+    export default traverse;
+}

packages/plugins/live-debugger/src/transform/functionId.ts

@@ -2,11 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-// @ts-nocheck - Babel type conflicts between @babel/parser and @babel/types versions
-import type { NodePath } from '@babel/traverse';
 import * as t from '@babel/types';
 import path from 'path';
 
+import type { BabelPath } from './babel-path.types';
+
 /**
  * Generate a stable, unique function ID
  * Format (POC): <relative-file-path>;<function-name>
@@ -18,7 +18,7 @@ import path from 'path';
 export function generateFunctionId(
     filePath: string,
     buildRoot: string,
-    functionPath: NodePath<t.Function>,
+    functionPath: BabelPath<t.Function>,
     anonymousSiblingIndex: number,
 ): string {
     const relativePath = path.relative(buildRoot, filePath).replace(/\\/g, '/');
@@ -36,12 +36,12 @@ export function generateFunctionId(
 /**
  * Get the name of a function if available
  */
-export function getFunctionName(functionPath: NodePath<t.Function>): string | null {
+export function getFunctionName(functionPath: BabelPath<t.Function>): string | null {
     const node = functionPath.node;
     const parent = functionPath.parent;
 
     // Named function declaration: function foo() {}
-    if (t.isIdentifier(node.id)) {
+    if ('id' in node && t.isIdentifier(node.id)) {
         return node.id.name;
     }
 
@@ -145,7 +145,7 @@ function getPropertyLikeName(key: t.Expression | t.PrivateName | t.Identifier):
     return null;
 }
 
-function getFunctionLocation(functionPath: NodePath<t.Function>): string {
+function getFunctionLocation(functionPath: BabelPath<t.Function>): string {
     const line = functionPath.node.loc?.start.line ?? 0;
     const column = functionPath.node.loc?.start.column ?? 0;
 

packages/plugins/live-debugger/src/transform/index.test.ts

@@ -291,7 +291,7 @@ describe('transformCode', () => {
             });
 
             expect(result.map).toBeDefined();
-            expect(result.map.sources).toContain('/src/utils.ts');
+            expect(result.map?.sources).toContain('/src/utils.ts');
         });
     });
 

packages/plugins/live-debugger/src/transform/index.ts

@@ -2,21 +2,20 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-import type { NodePath } from '@babel/traverse';
+import { parse } from '@babel/parser';
+import traverse from '@babel/traverse';
 import * as t from '@babel/types';
-// @ts-nocheck - Babel type conflicts between @babel/parser and @babel/types versions
+import type { SourceMap } from 'magic-string';
 import MagicString from 'magic-string';
 
 import { SKIP_INSTRUMENTATION_COMMENT } from '../constants';
 import type { FunctionKind } from '../types';
 
+import type { BabelPath } from './babel-path.types';
 import { generateFunctionId, getFunctionName } from './functionId';
 import { canInstrumentFunction, shouldSkipFunction } from './instrumentation';
 import { getVariableNames } from './scopeTracker';
 
-const { parse } = require('@babel/parser');
-const traverse = require('@babel/traverse').default;
-
 const HAS_FUNCTION_SYNTAX = /\bfunction\b|=>|\bclass\b|\)\s*\{/;
 
 interface ReturnInfo {
@@ -51,7 +50,7 @@ export interface TransformOptions {
 
 export interface TransformResult {
     code: string;
-    map?: any;
+    map?: SourceMap;
     failedCount: number;
     instrumentedCount: number;
     skippedByCommentCount: number;
@@ -109,7 +108,7 @@ export function transformCode(options: TransformOptions): TransformResult {
     let probeVarCounter = 0;
 
     traverse(ast, {
-        Function(path: NodePath<t.Function>) {
+        Function(path: BabelPath<t.Function>) {
             totalFunctions++;
 
             if (!canInstrumentFunction(path)) {
@@ -164,9 +163,10 @@ export function transformCode(options: TransformOptions): TransformResult {
                     bodyEnd: node.body.end!,
                     functionEnd: node.end!,
                     isExpressionBody,
-                    bodyParenStart: isExpressionBody
-                        ? (node.body.extra?.parenStart as number | undefined)
-                        : undefined,
+                    bodyParenStart:
+                        isExpressionBody && typeof node.body.extra?.parenStart === 'number'
+                            ? node.body.extra.parenStart
+                            : undefined,
                     functionId,
                     probeVarName,
                     probeIdx: String(idx),
@@ -425,7 +425,7 @@ export function validateSyntax(code: string, filePath: string): string | null {
             sourceFilename: filePath,
         });
         return null;
-    } catch (e: any) {
-        return e.message || String(e);
+    } catch (e: unknown) {
+        return e instanceof Error ? e.message : String(e);
     }
 }

packages/plugins/live-debugger/src/transform/instrumentation.ts

@@ -2,11 +2,11 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-// @ts-nocheck - Babel type conflicts between @babel/parser and @babel/types versions
-import type { NodePath } from '@babel/traverse';
 import * as t from '@babel/types';
 
-function hasSkipComment(path: NodePath, skipComment: string): boolean {
+import type { BabelPath } from './babel-path.types';
+
+function hasSkipComment(path: BabelPath, skipComment: string): boolean {
     if (path.node.leadingComments) {
         for (const comment of path.node.leadingComments) {
             if (comment.value.includes(skipComment)) {
@@ -30,10 +30,10 @@ function hasSkipComment(path: NodePath, skipComment: string): boolean {
  * the comment to the ExportNamedDeclaration, one level above the statement.
  */
 export function shouldSkipFunction(
-    functionPath: NodePath<t.Function>,
+    functionPath: BabelPath<t.Function>,
     skipComment: string,
 ): boolean {
-    let current: NodePath | null = functionPath;
+    let current: BabelPath | null = functionPath;
 
     while (current) {
         if (hasSkipComment(current, skipComment)) {
@@ -42,10 +42,10 @@ export function shouldSkipFunction(
 
         // Stop once we reach a statement or export declaration — that is the
         // outermost node where Babel would attach a line-level leading comment.
-        if (current.isStatement() || current.isExportDeclaration()) {
+        if (t.isStatement(current.node) || t.isExportDeclaration(current.node)) {
             // For `export const fn = ...`, the comment is on the ExportDeclaration
             // which wraps the VariableDeclaration statement.
-            if (current.parentPath?.isExportDeclaration()) {
+            if (current.parentPath && t.isExportDeclaration(current.parentPath.node)) {
                 return hasSkipComment(current.parentPath, skipComment);
             }
             break;
@@ -61,7 +61,7 @@ export function shouldSkipFunction(
  * Check if function should be instrumented
  * Skips: generators and constructors
  */
-export function canInstrumentFunction(functionPath: NodePath<t.Function>): boolean {
+export function canInstrumentFunction(functionPath: BabelPath<t.Function>): boolean {
     const node = functionPath.node;
 
     // Skip generators

packages/plugins/live-debugger/src/transform/scopeTracker.ts

@@ -2,7 +2,6 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-// @ts-nocheck - Babel type conflicts between @babel/parser and @babel/types versions
 import * as t from '@babel/types';
 
 export const MAX_CAPTURE_VARIABLES = 25;
@@ -34,7 +33,8 @@ export function getVariableNames(
 
     if (includeLocals && t.isBlockStatement(functionNode.body)) {
         const paramSet = new Set(functionNode.params.flatMap((p) => getPatternIdentifiers(p)));
-        const functionName = t.isIdentifier(functionNode.id) ? functionNode.id.name : '';
+        const functionName =
+            'id' in functionNode && t.isIdentifier(functionNode.id) ? functionNode.id.name : '';
 
         for (const stmt of functionNode.body.body) {
             if (t.isVariableDeclaration(stmt)) {
@@ -56,15 +56,7 @@ export function getVariableNames(
     return variables;
 }
 
-function getPatternIdentifiers(
-    pattern:
-        | t.Identifier
-        | t.RestElement
-        | t.AssignmentPattern
-        | t.ObjectPattern
-        | t.ArrayPattern
-        | t.TSParameterProperty,
-): string[] {
+function getPatternIdentifiers(pattern: t.Node): string[] {
     if (t.isIdentifier(pattern)) {
         return [pattern.name];
     }
@@ -85,7 +77,7 @@ function getPatternIdentifiers(
                 return getPatternIdentifiers(property.argument);
             }
 
-            return getPatternIdentifiers(property.value as typeof pattern);
+            return getPatternIdentifiers(property.value);
         });
     }
 
@@ -95,7 +87,7 @@ function getPatternIdentifiers(
                 return [];
             }
 
-            return getPatternIdentifiers(element as typeof pattern);
+            return getPatternIdentifiers(element);
         });
     }