Untangle the funcCount / rootCount confusion and simplify lower wing call node info.

Author: mstange

src/profile-logic/call-node-info.ts

@@ -608,10 +608,23 @@ export interface CallNodeInfoInverted extends CallNodeInfo {
     nodeHandle: IndexIntoCallNodeTable
   ): [SuffixOrderIndex, SuffixOrderIndex];
 
-  // The number of functions. There is one root in the inverted tree per func,
-  // and the inverted root's call node handle equals the func index.
+  // The number of functions in the func table this CNI was built from.
+  // (Sizes per-func scratch buffers in callers; not directly tied to the
+  // number of inverted-tree roots — see getRootCount.)
   getFuncCount(): number;
 
+  // The number of roots in the inverted tree. Root call node handles are
+  // 0..getRootCount()-1. For the full inverted tree this equals funcCount
+  // (one root per func); for a lower-wing CNI it is 1.
+  getRootCount(): number;
+
+  // Returns the inverted root call node handle for `funcIndex`, or -1 if no
+  // root in this CNI corresponds to that function (e.g. a lower-wing CNI only
+  // has a root for its selected func).
+  getRootNodeForFunc(
+    funcIndex: IndexIntoFuncTable
+  ): IndexIntoCallNodeTable | -1;
+
   // True if the given node is a root of the inverted tree.
   isRoot(nodeHandle: IndexIntoCallNodeTable): boolean;
 
@@ -1059,13 +1072,23 @@ export class LazyInvertedCallNodeInfo implements CallNodeInfoInverted {
     return this._suffixOrderIndexes;
   }
 
-  // Get the number of functions. There is one root per function.
-  // So this is also the number of roots at the same time.
-  // The inverted call node index for a root is the same as the function index.
+  // Get the number of functions. There is one root per function in this
+  // (full inverted) CNI, so it also equals getRootCount().
+  // For roots, the inverted call node handle equals the function index.
   getFuncCount(): number {
     return this._rootCount;
   }
 
+  getRootCount(): number {
+    return this._rootCount;
+  }
+
+  // For the full inverted tree, each func has its own root and the root
+  // handle equals the func index.
+  getRootNodeForFunc(funcIndex: IndexIntoFuncTable): InvertedCallNodeHandle {
+    return funcIndex;
+  }
+
   // Returns whether the given node is a root node.
   isRoot(nodeHandle: InvertedCallNodeHandle): boolean {
     return nodeHandle < this._rootCount;
@@ -1757,9 +1780,9 @@ export class LazyInvertedCallNodeInfo implements CallNodeInfoInverted {
 }
 
 // The lower wing's inverted call node table. Index 0 is the selected-func
-// root; indices 1..length-1 are non-root nodes. The public handle scheme
-// (rootHandle === funcIndex, non-root handles start at funcCount) is preserved
-// by the accessors, which translate handle ↔ table index.
+// root; indices 1..length-1 are non-root nodes. The public InvertedCallNodeHandle
+// IS the table index (no translation): handle 0 is the root, handles
+// 1..length-1 are non-roots.
 //
 // Layout note: rows are appended in BFS-by-inverted-depth order, with each
 // parent's children emitted contiguously, sorted by func index. Index 0 is the
@@ -1801,19 +1824,23 @@ export type LowerWingTable = {
  *    only renders the rows currently in the viewport, so building deeper than
  *    necessary is wasted work.
  *
- * Conventions kept from LazyInvertedCallNodeInfo so consumers (especially
- * CallTreeInternalInverted and computeCallTreeTimingsInverted) work unchanged:
- *  - There are funcCount logical roots, with rootHandle === funcIndex.
- *    Only the root at selectedFuncIndex has non-empty data.
- *  - Non-root handles start at funcCount.
+ * Handle scheme:
+ *  - There is exactly one root, with handle === 0. Its func is `selectedFuncIndex`
+ *    (or 0 when no selection — the row is then a placeholder with no children).
+ *  - Non-root handles are 1..length-1 and equal their table index. Handles
+ *    other than 0 only exist after the BFS has expanded to materialize them.
+ *  - `getRootNodeForFunc(f)` returns 0 iff f === selectedFuncIndex, else -1.
  *  - `getSuffixOrderedCallNodes()` and `getSuffixOrderIndexes()` are kept in
  *    sync as the BFS refines partitions.
  */
 export class LowerWingCallNodeInfo implements CallNodeInfoInverted {
   _callNodeTable: CallNodeTable;
   _stackIndexToNonInvertedCallNodeIndex: Int32Array;
   _defaultCategory: IndexIntoCategoryList;
-  _rootCount: number;
+  // Number of functions in the originating func table. Used to size per-func
+  // scratch buffers in `_extendToDepth`; unrelated to the number of roots
+  // (which is always 1 — see getRootCount).
+  _funcCount: number;
   _selectedFuncIndex: IndexIntoFuncTable | null;
 
   // Suffix-ordered entry points: maps suffix order index -> non-inverted call
@@ -1884,7 +1911,7 @@ export class LowerWingCallNodeInfo implements CallNodeInfoInverted {
     this._stackIndexToNonInvertedCallNodeIndex =
       stackIndexToNonInvertedCallNodeIndex;
     this._defaultCategory = defaultCategory;
-    this._rootCount = funcCount;
+    this._funcCount = funcCount;
     this._selectedFuncIndex = selectedFuncIndex;
 
     // Pass 1: collect root-most non-inverted nodes whose func is the selected
@@ -2007,38 +2034,35 @@ export class LowerWingCallNodeInfo implements CallNodeInfoInverted {
   }
 
   getFuncCount(): number {
-    return this._rootCount;
+    return this._funcCount;
+  }
+
+  getRootCount(): number {
+    return 1;
+  }
+
+  // Only the selected func has a root in this CNI. Other funcs return -1.
+  getRootNodeForFunc(
+    funcIndex: IndexIntoFuncTable
+  ): InvertedCallNodeHandle | -1 {
+    return funcIndex === this._selectedFuncIndex ? 0 : -1;
   }
 
   isRoot(nodeHandle: InvertedCallNodeHandle): boolean {
-    return nodeHandle < this._rootCount;
+    return nodeHandle === 0;
   }
 
   getSuffixOrderIndexRangeForCallNode(
     nodeHandle: InvertedCallNodeHandle
   ): [SuffixOrderIndex, SuffixOrderIndex] {
-    if (nodeHandle < this._rootCount) {
-      if (nodeHandle === this._selectedFuncIndex) {
-        return [this._tSoStart[0], this._tSoEnd[0]];
-      }
-      return [0, 0];
-    }
-    const idx = nodeHandle - this._rootCount + 1;
-    return [this._tSoStart[idx], this._tSoEnd[idx]];
+    return [this._tSoStart[nodeHandle], this._tSoEnd[nodeHandle]];
   }
 
   getChildren(nodeIndex: InvertedCallNodeHandle): InvertedCallNodeHandle[] {
-    if (nodeIndex < this._rootCount) {
-      if (nodeIndex !== this._selectedFuncIndex) {
-        return EMPTY_LOWER_WING_CHILDREN;
-      }
-      // Root: depth 0 — process it (if needed) so children are populated.
-      this._extendToDepth(0);
-      return this._tChildren[0];
-    }
-    const idx = nodeIndex - this._rootCount + 1;
-    this._extendToDepth(this._tDepth[idx]);
-    return this._tChildren[idx];
+    // Extend the BFS far enough for this node to have its children
+    // materialized (depth 0 for the root, depth d for a node at depth d).
+    this._extendToDepth(this._tDepth[nodeIndex]);
+    return this._tChildren[nodeIndex];
   }
 
   getCallNodePathFromIndex(
@@ -2049,12 +2073,11 @@ export class LowerWingCallNodeInfo implements CallNodeInfoInverted {
     }
     const callNodePath: number[] = [];
     let current = callNodeHandle;
-    while (current >= this._rootCount) {
-      const idx = current - this._rootCount + 1;
-      callNodePath.push(this._tFunc[idx]);
-      current = this._tPrefix[idx];
+    while (current !== 0) {
+      callNodePath.push(this._tFunc[current]);
+      current = this._tPrefix[current];
     }
-    callNodePath.push(current); // root: handle === func
+    callNodePath.push(this._tFunc[0]);
     callNodePath.reverse();
     return callNodePath;
   }
@@ -2065,14 +2088,12 @@ export class LowerWingCallNodeInfo implements CallNodeInfoInverted {
     if (callNodePath.length === 0) {
       return null;
     }
-    // Reject paths that don't start at the selected func — only that root has
-    // any descendants.
+    // The only root in this CNI is for the selected func. Any path that doesn't
+    // start there has no match.
     if (callNodePath[0] !== this._selectedFuncIndex) {
-      // The first func is also a valid root handle (handle === func), but only
-      // the selected func's path can be reached beyond depth 0.
-      return callNodePath.length === 1 ? callNodePath[0] : null;
+      return null;
     }
-    let handle: InvertedCallNodeHandle = callNodePath[0];
+    let handle: InvertedCallNodeHandle = 0;
     for (let i = 1; i < callNodePath.length; i++) {
       const next = this.getCallNodeIndexFromParentAndFunc(
         handle,
@@ -2091,7 +2112,7 @@ export class LowerWingCallNodeInfo implements CallNodeInfoInverted {
     func: IndexIntoFuncTable
   ): InvertedCallNodeHandle | null {
     if (parent === -1) {
-      return func; // For roots, handle === func.
+      return this.getRootNodeForFunc(func) === -1 ? null : 0;
     }
     const children = this.getChildren(parent);
     // Children are sorted by func; bisect to find a match.
@@ -2108,68 +2129,39 @@ export class LowerWingCallNodeInfo implements CallNodeInfoInverted {
   prefixForNode(
     callNodeHandle: InvertedCallNodeHandle
   ): InvertedCallNodeHandle | -1 {
-    if (callNodeHandle < this._rootCount) {
-      return -1;
-    }
-    return this._tPrefix[callNodeHandle - this._rootCount + 1];
+    return this._tPrefix[callNodeHandle];
   }
 
   funcForNode(callNodeHandle: InvertedCallNodeHandle): IndexIntoFuncTable {
-    if (callNodeHandle < this._rootCount) {
-      return callNodeHandle; // root handle === func index
-    }
-    return this._tFunc[callNodeHandle - this._rootCount + 1];
+    return this._tFunc[callNodeHandle];
   }
 
   categoryForNode(
     callNodeHandle: InvertedCallNodeHandle
   ): IndexIntoCategoryList {
-    if (callNodeHandle < this._rootCount) {
-      return callNodeHandle === this._selectedFuncIndex
-        ? this._tCategory[0]
-        : this._defaultCategory;
-    }
-    return this._tCategory[callNodeHandle - this._rootCount + 1];
+    return this._tCategory[callNodeHandle];
   }
 
   subcategoryForNode(
     callNodeHandle: InvertedCallNodeHandle
   ): IndexIntoSubcategoryListForCategory {
-    if (callNodeHandle < this._rootCount) {
-      return callNodeHandle === this._selectedFuncIndex
-        ? this._tSubcategory[0]
-        : 0;
-    }
-    return this._tSubcategory[callNodeHandle - this._rootCount + 1];
+    return this._tSubcategory[callNodeHandle];
   }
 
   innerWindowIDForNode(
     callNodeHandle: InvertedCallNodeHandle
   ): IndexIntoCategoryList {
-    if (callNodeHandle < this._rootCount) {
-      return callNodeHandle === this._selectedFuncIndex
-        ? this._tInnerWindowID[0]
-        : 0;
-    }
-    return this._tInnerWindowID[callNodeHandle - this._rootCount + 1];
+    return this._tInnerWindowID[callNodeHandle];
   }
 
   depthForNode(callNodeHandle: InvertedCallNodeHandle): number {
-    if (callNodeHandle < this._rootCount) {
-      return 0;
-    }
-    return this._tDepth[callNodeHandle - this._rootCount + 1];
+    return this._tDepth[callNodeHandle];
   }
 
   sourceFramesInlinedIntoSymbolForNode(
     callNodeHandle: InvertedCallNodeHandle
   ): IndexIntoNativeSymbolTable | -1 | -2 {
-    if (callNodeHandle < this._rootCount) {
-      return callNodeHandle === this._selectedFuncIndex
-        ? (this._tInlinedInto[0] as IndexIntoNativeSymbolTable | -1 | -2)
-        : -2;
-    }
-    return this._tInlinedInto[callNodeHandle - this._rootCount + 1] as
+    return this._tInlinedInto[callNodeHandle] as
       | IndexIntoNativeSymbolTable
       | -1
       | -2;
@@ -2242,7 +2234,6 @@ export class LowerWingCallNodeInfo implements CallNodeInfoInverted {
     const scratchSelf = this._scratchSelf;
     const scratchDeep = this._scratchDeep;
     const defaultCategory = this._defaultCategory;
-    const funcCount = this._rootCount;
 
     // Scratch list of distinct funcs seen in Pass 1 of the current node.
     // Cleared at the top of each iteration.
@@ -2257,7 +2248,8 @@ export class LowerWingCallNodeInfo implements CallNodeInfoInverted {
       const parentSuffixStart = tSoStart[k];
       const parentSuffixEnd = tSoEnd[k];
       const parentDepth = tDepth[k];
-      const parentHandle = k === 0 ? tFunc[0] : funcCount + k - 1;
+      // Public handle === table index.
+      const parentHandle = k;
 
       // Pass 1: walk each entry's deepNode one step up, bucket-counting by
       // the new deepNode's func. Entries whose chain bottoms out are tallied
@@ -2359,7 +2351,9 @@ export class LowerWingCallNodeInfo implements CallNodeInfoInverted {
           }
         }
 
-        const newHandle = funcCount + tPrefix.length - 1;
+        // Public handle === table index, which is the slot the child row is
+        // about to be pushed into.
+        const newHandle = tPrefix.length;
         tPrefix.push(parentHandle);
         tFunc.push(f);
         tCategory.push(category);