@abreen/tada 1.13.9 → 1.14.2

package/build/utils/trace-core.ts

@@ -5,8 +5,14 @@ import { renderCodeSegment } from './code';
 import { splitLines } from './literate-java';
 import { normalizeOutputPath } from './paths';
 import { computeLayout } from './trace-layout';
-import { generateStepSvg } from './trace-svg';
-import type { TraceChunkEntry, TraceManifest, TraceStep } from '../types';
+import { filterStep, generateStepSvg } from './trace-svg';
+import type {
+  TraceChunkEntry,
+  TraceHeapObject,
+  TraceManifest,
+  TraceOutputEvent,
+  TraceStep,
+} from '../types';
 
 export const DEFAULT_CHUNK_SIZE = 50;
 
@@ -21,6 +27,10 @@ export interface ChunkTraceOutputResult {
   outputPaths: string[];
 }
 
+function stepOutputEvents(step: TraceStep): TraceOutputEvent[] {
+  return step.output ?? [];
+}
+
 function hashTraceFiles(files: { name: string; content: string }[]): string {
   const hasher = createHash('sha256');
   for (const file of files) {
@@ -32,6 +42,10 @@ function hashTraceFiles(files: { name: string; content: string }[]): string {
   return `sha256-${hasher.digest('hex').slice(0, 16)}`;
 }
 
+function safeSvgIdPart(value: string): string {
+  return value.replace(/[^A-Za-z0-9_-]+/g, '-').replace(/^-+|-+$/g, '');
+}
+
 function buildTraceOutputPath(
   relDir: string,
   traceName: string,
@@ -43,13 +57,101 @@ function buildTraceOutputPath(
     .join('/');
 }
 
+function escapeAttr(value: string): string {
+  return value
+    .replaceAll('&', '&')
+    .replaceAll('"', '"')
+    .replaceAll('<', '&lt;')
+    .replaceAll('>', '&gt;');
+}
+
+function framesMatchCaller(previous: TraceStep, current: TraceStep): boolean {
+  if (current.stack.length !== previous.stack.length - 1) {
+    return false;
+  }
+
+  return current.stack.every((frame, index) => {
+    const previousFrame = previous.stack[index + 1];
+    return (
+      frame.method === previousFrame.method &&
+      frame.class === previousFrame.class
+    );
+  });
+}
+
+function addReachableHeapObjects(
+  id: string,
+  source: Record<string, TraceHeapObject>,
+  target: Record<string, TraceHeapObject>,
+): void {
+  const queue = [id];
+  const seen = new Set<string>();
+
+  while (queue.length > 0) {
+    const currentId = queue.shift()!;
+    if (seen.has(currentId) || !source[currentId]) {
+      continue;
+    }
+    seen.add(currentId);
+    target[currentId] ??= source[currentId];
+
+    const obj = source[currentId];
+    if ('elements' in obj) {
+      for (const element of obj.elements) {
+        if (element.type === 'ref') {
+          queue.push(element.id);
+        }
+      }
+    } else if ('fields' in obj) {
+      for (const value of Object.values(obj.fields)) {
+        if (value.type === 'ref') {
+          queue.push(value.id);
+        }
+      }
+    }
+  }
+}
+
+export function bridgeConstructorReturnValues(steps: TraceStep[]): TraceStep[] {
+  const bridgedSteps = steps.map(step => ({
+    ...step,
+    heap: { ...step.heap },
+    transientHeapRoots: step.transientHeapRoots
+      ? [...step.transientHeapRoots]
+      : undefined,
+  }));
+
+  for (let i = 1; i < bridgedSteps.length; i++) {
+    const previous = bridgedSteps[i - 1];
+    const current = bridgedSteps[i];
+    const poppedFrame = previous.stack[0];
+    const thisValue = poppedFrame?.locals.this;
+
+    if (
+      poppedFrame?.method !== '<init>' ||
+      thisValue?.type !== 'ref' ||
+      !framesMatchCaller(previous, current)
+    ) {
+      continue;
+    }
+
+    addReachableHeapObjects(thisValue.id, previous.heap, current.heap);
+    current.transientHeapRoots ??= [];
+    if (!current.transientHeapRoots.includes(thisValue.id)) {
+      current.transientHeapRoots.push(thisValue.id);
+    }
+  }
+
+  return bridgedSteps;
+}
+
 export function chunkTraceOutput(
   output: string,
   traceOutputDir: string,
   relDir: string,
   traceName: string,
-  sourceFile: string,
-  source: string,
+  primaryFile: string,
+  sources: { file: string; source: string }[],
   options: ChunkTraceOutputOptions = {},
 ): ChunkTraceOutputResult {
   const chunkSize = options.chunkSize ?? DEFAULT_CHUNK_SIZE;
@@ -60,26 +162,48 @@ export function chunkTraceOutput(
     .split('\n')
     .filter(l => l.length > 0);
 
-  const allSteps: TraceStep[] = lines.map(l => JSON.parse(l));
+  const allSteps: TraceStep[] = bridgeConstructorReturnValues(
+    lines.map(l => JSON.parse(l)),
+  );
 
-  const lineToSteps: Record<number, number[]> = {};
+  const lineToStepsByFile = new Map<string, Record<number, number[]>>();
+  for (const source of sources) {
+    lineToStepsByFile.set(source.file, {});
+  }
   for (let i = 0; i < allSteps.length; i++) {
     const step = allSteps[i];
+    const file = path.basename(step.file);
+    const lineToSteps = lineToStepsByFile.get(file);
+    if (!lineToSteps) {
+      continue;
+    }
     if (!lineToSteps[step.line]) {
       lineToSteps[step.line] = [];
     }
     lineToSteps[step.line].push(i);
   }
 
-  const layout = computeLayout(allSteps, ignoreFields);
+  const layoutSteps = allSteps.map(step => ({ ...step, ...filterStep(step) }));
+  const layout = computeLayout(layoutSteps, ignoreFields);
+  const svgIdPrefix = safeSvgIdPart(traceName) || 'trace';
 
   let chunkEntries: TraceChunkEntry[] = [];
   let chunkIndex = 0;
   const chunkFiles: { name: string; content: string }[] = [];
 
-  for (const step of allSteps) {
-    const svg = generateStepSvg(step, layout);
-    chunkEntries.push({ line: step.line, stdout: step.stdout, svg });
+  for (const [stepIndex, step] of allSteps.entries()) {
+    const svg = generateStepSvg(
+      step,
+      layout,
+      undefined,
+      `trace-${svgIdPrefix}-${stepIndex}`,
+    );
+    chunkEntries.push({
+      file: path.basename(step.file),
+      line: step.line,
+      output: stepOutputEvents(step),
+      svg,
+    });
 
     if (chunkEntries.length >= chunkSize) {
       chunkFiles.push({
@@ -101,9 +225,11 @@ export function chunkTraceOutput(
   const manifest: TraceManifest = {
     totalSteps: allSteps.length,
     chunkSize,
-    sourceFile,
-    source,
-    lineToSteps,
+    primaryFile,
+    sources: sources.map(source => ({
+      ...source,
+      lineToSteps: lineToStepsByFile.get(source.file) ?? {},
+    })),
   };
 
   const manifestFile = {
@@ -218,11 +344,11 @@ export function buildManifestUrl({
 }
 
 export function renderTraceWidgetHtml({
-  highlightedSource,
+  highlightedSources,
   manifestUrl,
   totalSteps,
 }: {
-  highlightedSource: string;
+  highlightedSources: { file: string; highlightedSource: string }[];
   manifestUrl?: string;
   totalSteps?: number;
 }): string {
@@ -248,5 +374,11 @@ export function renderTraceWidgetHtml({
   const wrapperClass = disabled
     ? 'trace-widget trace-disabled'
     : 'trace-widget';
-  return `<div class="${wrapperClass}"${wrapperAttrs}><noscript><p>This interactive trace requires JavaScript.</p></noscript><div class="trace-body"><div class="trace-toolbar"><div class="trace-controls" role="toolbar" aria-label="Trace navigation">${controls}</div></div><div class="trace-content"><div class="trace-diagram"></div><div class="trace-source-wrapper"><div class="trace-source">${highlightedSource}</div></div></div></div></div>`;
+  const sourcePanels = highlightedSources
+    .map((source, index) => {
+      const hidden = index === 0 ? '' : ' hidden';
+      return `<div class="trace-source" data-trace-source-file="${escapeAttr(source.file)}"${hidden}>${source.highlightedSource}</div>`;
+    })
+    .join('');
+  return `<div class="${wrapperClass}"${wrapperAttrs}><noscript><p>This interactive trace requires JavaScript.</p></noscript><div class="trace-body"><div class="trace-toolbar"><div class="trace-controls" role="toolbar" aria-label="Trace navigation">${controls}</div></div><div class="trace-content"><div class="trace-diagram"></div><div class="trace-source-wrapper">${sourcePanels}</div></div></div></div>`;
 }

package/build/utils/trace-heap.ts

@@ -0,0 +1,34 @@
+import type { TraceHeapObject } from '../types';
+
+export type TraceHeapScalar = string | number | boolean;
+
+const BOXED_PRIMITIVE_TYPES = new Set([
+  'java.lang.Boolean',
+  'java.lang.Byte',
+  'java.lang.Character',
+  'java.lang.Double',
+  'java.lang.Float',
+  'java.lang.Integer',
+  'java.lang.Long',
+  'java.lang.Short',
+]);
+
+export function isInlineHeapObject(obj: TraceHeapObject): boolean {
+  return (
+    'value' in obj &&
+    (obj.type === 'String' || BOXED_PRIMITIVE_TYPES.has(obj.type))
+  );
+}
+
+export function formatHeapObjectValue(
+  type: string,
+  value: TraceHeapScalar,
+): string {
+  if (type === 'String') {
+    return `"${value}"`;
+  }
+  if (type === 'java.lang.Character') {
+    return `'${value}'`;
+  }
+  return String(value);
+}

package/build/utils/trace-java.ts

@@ -2,11 +2,17 @@ import fs from 'fs';
 import os from 'os';
 import path from 'path';
 import { execFileSync } from 'child_process';
+import { parse as parseJava } from 'java-parser';
 import { makeLogger } from '../log';
 import { hasMainMethod, runJavac } from './literate-java';
 
 const log = makeLogger(import.meta.url);
 
+interface CstNode {
+  name?: string;
+  children?: Record<string, CstNode[]>;
+}
+
 /**
  * Parse // @trace-ignore comments from Java source code.
  * Returns a map of className -> fieldName[] for fields that should be
@@ -65,6 +71,42 @@ export function parseIgnoreFields(source: string): Record<string, string[]> {
   return result;
 }
 
+const JAVA_TOP_LEVEL_TYPE_NODES = new Set([
+  'classDeclaration',
+  'interfaceDeclaration',
+  'enumDeclaration',
+  'recordDeclaration',
+]);
+
+export function hasExplicitTopLevelTypeDeclaration(source: string): boolean {
+  let cst: CstNode;
+  try {
+    cst = parseJava(source) as CstNode;
+  } catch (err: unknown) {
+    log.debug`Failed to parse Java source for unnamed class detection: ${(err as Error).message}`;
+    return true;
+  }
+
+  const ordinaryCompilationUnit = cst.children?.ordinaryCompilationUnit?.[0];
+  const typeDeclarations =
+    ordinaryCompilationUnit?.children?.typeDeclaration ?? [];
+
+  return typeDeclarations.some(typeDeclaration =>
+    Object.keys(typeDeclaration.children ?? {}).some(childName =>
+      JAVA_TOP_LEVEL_TYPE_NODES.has(childName),
+    ),
+  );
+}
+
+export function getUnnamedClassNames(javaFilePaths: string[]): string[] {
+  return javaFilePaths
+    .filter(javaFilePath => {
+      const source = fs.readFileSync(javaFilePath, 'utf-8');
+      return !hasExplicitTopLevelTypeDeclaration(source);
+    })
+    .map(javaFilePath => path.parse(javaFilePath).name);
+}
+
 let tracerClassDir: string | null = null;
 
 function ensureTracerCompiled(): string {
@@ -87,7 +129,7 @@ function ensureTracerCompiled(): string {
   return tempDir;
 }
 
-function compileTargetFile(javaFilePath: string): string {
+function compileTargetFiles(javaFilePaths: string[]): string {
   const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'tada-trace-target-'));
 
   runJavac(
@@ -96,10 +138,10 @@ function compileTargetFile(javaFilePath: string): string {
       '-d',
       tempDir,
       '-sourcepath',
-      path.dirname(javaFilePath),
-      javaFilePath,
+      path.dirname(javaFilePaths[0]),
+      ...javaFilePaths,
     ],
-    { tempDir, label: `Compilation failed for ${javaFilePath}` },
+    { tempDir, label: `Compilation failed for ${javaFilePaths[0]}` },
   );
 
   return tempDir;
@@ -116,14 +158,25 @@ export function validateJavaTraceTarget(
   }
 }
 
-export function runJavaTrace(javaFilePath: string, className: string): string {
-  const targetClassDir = compileTargetFile(javaFilePath);
+export function runJavaTrace(
+  javaFilePaths: string[],
+  className: string,
+): string {
+  const targetClassDir = compileTargetFiles(javaFilePaths);
 
   try {
     const tracerDir = ensureTracerCompiled();
+    const unnamedClassNames = getUnnamedClassNames(javaFilePaths);
     return execFileSync(
       'java',
-      ['-cp', tracerDir, 'TraceRunner', className, targetClassDir],
+      [
+        '-cp',
+        tracerDir,
+        'TraceRunner',
+        className,
+        targetClassDir,
+        ...unnamedClassNames,
+      ],
       { timeout: 60000, encoding: 'utf-8', maxBuffer: 50 * 1024 * 1024 },
     );
   } finally {

package/build/utils/trace-layout.ts

@@ -5,6 +5,11 @@ import type {
   TraceLayout,
   TraceObjectLayout,
 } from '../types';
+import {
+  formatHeapObjectValue,
+  isInlineHeapObject,
+  type TraceHeapScalar,
+} from './trace-heap';
 
 /** Maximum number of array cells to display. */
 export const ARRAY_MAX_CELLS = 12;
@@ -24,6 +29,9 @@ const ROW_HEIGHT_RATIO = 2;
 /** Minimum width for a value box in a field object. */
 const MIN_VALUE_WIDTH = 40;
 
+/** Minimum width for each displayed array cell. */
+const MIN_ARRAY_CELL_WIDTH = 48;
+
 /** Information collected about a heap object across all trace steps. */
 export interface ObjectInfo {
   id: string;
@@ -32,14 +40,18 @@ export interface ObjectInfo {
   lastStep: number;
   /** Set of object IDs this object ever references (across all steps). */
   references: Set<string>;
+  /** Step indices where this object is actually present. */
+  activeSteps: Set<number>;
   /** Per-field reference targets (field name -> set of referenced object IDs). */
   fieldRefs: Map<string, Set<string>>;
   /** Max number of fields seen on this object (for field objects). */
   maxFields: number;
   /** Max number of elements seen on this object (for arrays). */
   maxElements: number;
-  /** String value (for string-valued objects). */
-  value: string | null;
+  /** Scalar value (for heap objects represented by a single value). */
+  value: TraceHeapScalar | null;
+  hasValue: boolean;
+  isInlineValue: boolean;
   isArray: boolean;
   isString: boolean;
   /** All field names ever seen on this object. */
@@ -74,10 +86,13 @@ export function scanSteps(steps: TraceStep[]): Map<string, ObjectInfo> {
           firstStep: stepIndex,
           lastStep: stepIndex,
           references: new Set(),
+          activeSteps: new Set(),
           fieldRefs: new Map(),
           maxFields: 0,
           maxElements: 0,
           value: null,
+          hasValue: false,
+          isInlineValue: false,
           isArray: false,
           isString: false,
           fieldNames: new Set(),
@@ -87,6 +102,7 @@ export function scanSteps(steps: TraceStep[]): Map<string, ObjectInfo> {
       }
 
       info.lastStep = stepIndex;
+      info.activeSteps.add(stepIndex);
 
       if ('elements' in obj) {
         info.isArray = true;
@@ -125,7 +141,9 @@ export function scanSteps(steps: TraceStep[]): Map<string, ObjectInfo> {
           }
         }
       } else if ('value' in obj) {
-        info.isString = true;
+        info.hasValue = true;
+        info.isString = obj.type === 'String';
+        info.isInlineValue ||= isInlineHeapObject(obj);
         info.value = obj.value;
       }
     }
@@ -229,17 +247,24 @@ export function getObjectSize(
   const charWidth = fontSize * CHAR_WIDTH_RATIO;
   const rowHeight = fontSize * ROW_HEIGHT_RATIO;
 
-  if (info.isString) {
-    const text = `"${info.value ?? ''}"`;
+  if (info.isInlineValue) {
+    const text = formatHeapObjectValue(info.type, info.value ?? '');
+    const textWidth = text.length * charWidth;
+    const minWidth = info.isString ? info.type.length * charWidth + 16 : 16;
+    const width = Math.max(minWidth, textWidth + 16);
+    return { width, height: rowHeight * 2 };
+  }
+
+  if (info.hasValue) {
+    const text = String(info.value ?? '');
     const textWidth = text.length * charWidth;
     const width = Math.max(info.type.length * charWidth + 16, textWidth + 16);
-    const height = rowHeight * 2; // header + value
-    return { width, height };
+    return { width, height: rowHeight * 2 };
   }
 
   if (info.isArray) {
     const cellCount = Math.min(info.maxElements, ARRAY_MAX_CELLS);
-    const cellWidth = Math.max(charWidth * 3, MIN_VALUE_WIDTH);
+    const cellWidth = Math.max(charWidth * 3, MIN_ARRAY_CELL_WIDTH);
     const width = Math.max(
       info.type.length * charWidth + 16,
       cellCount * cellWidth,
@@ -754,6 +779,13 @@ function layoutArrays(
         };
       });
 
+      const minPlacementX = Math.min(...placements.map(p => p.x));
+      if (minPlacementX < 0) {
+        for (const p of placements) {
+          p.x -= minPlacementX;
+        }
+      }
+
       const gap = Math.round(OBJ_GAP * 0.5);
       for (let j = 1; j < placements.length; j++) {
         const prev = placements[j - 1];
@@ -767,7 +799,7 @@ function layoutArrays(
       const refY = Math.round(yOffset + size.height + OBJ_GAP);
       let maxRefHeight = 0;
       for (const p of placements) {
-        result[p.id] = makeLayout(Math.round(Math.max(0, p.x)), refY, p.size);
+        result[p.id] = makeLayout(Math.round(p.x), refY, p.size);
         maxRefHeight = Math.max(maxRefHeight, p.height);
       }
 
@@ -789,7 +821,11 @@ function layoutOrphans(
   result: Record<string, TraceObjectLayout>,
   yOffset: number,
 ) {
-  type OrphanSlot = { ids: string[]; lastStep: number; maxHeight: number };
+  type OrphanSlot = {
+    ids: string[];
+    activeSteps: Set<number>;
+    maxHeight: number;
+  };
 
   const orphanIds = [...objects.keys()]
     .filter(id => !(id in result))
@@ -806,14 +842,23 @@ function layoutOrphans(
     const info = objects.get(id)!;
     const size = sizes.get(id)!;
 
-    let slot = slots.find(existing => existing.lastStep < info.firstStep);
+    let slot = slots.find(existing => {
+      for (const stepIndex of info.activeSteps) {
+        if (existing.activeSteps.has(stepIndex)) {
+          return false;
+        }
+      }
+      return true;
+    });
     if (!slot) {
-      slot = { ids: [], lastStep: info.lastStep, maxHeight: size.height };
+      slot = { ids: [], activeSteps: new Set(), maxHeight: size.height };
       slots.push(slot);
     } else {
-      slot.lastStep = info.lastStep;
       slot.maxHeight = Math.max(slot.maxHeight, size.height);
     }
+    for (const stepIndex of info.activeSteps) {
+      slot.activeSteps.add(stepIndex);
+    }
     slot.ids.push(id);
   }
 

package/build/utils/trace-python.ts

@@ -1,7 +1,10 @@
 import path from 'path';
 import { execFileSyncPython, resolvePythonCommand } from '../../python/command';
 
-export function runPythonTrace(pythonFilePath: string): string {
+export function runPythonTrace(
+  pythonFilePath: string,
+  tracedFilePaths: string[],
+): string {
   const pythonCommand = resolvePythonCommand();
   if (!pythonCommand) {
     throw new Error('Python is required to generate Python traces');
@@ -16,10 +19,11 @@ export function runPythonTrace(pythonFilePath: string): string {
     timeout: 60000,
     encoding: 'utf-8' as const,
     maxBuffer: 50 * 1024 * 1024,
+    cwd: path.dirname(pythonFilePath),
   };
 
   return execFileSyncPython(
-    [runnerPath, pythonFilePath],
+    [runnerPath, pythonFilePath, ...tracedFilePaths],
     options,
     pythonCommand,
   );