perf: fully inline _getCachedSource in source() and split CachedSource ctor

claude · claude · commit 03fed1e8c9e4 · 2026-04-22T17:20:39.000Z
Two follow-ups to keep CodSpeed happy: 1. `source()` previously inlined only the warm `_cachedSource` check and still called `_getCachedSource()` on cold reads, which under the interpreter (CodSpeed's simulation mode) pays a function-call stack frame plus a redundant re-check of `_cachedSource`. Inline the whole helper body so both warm and cold paths stay branchless-to-call. Local --no-opt: cold `new CachedSource(RawSource).source()` drops 534 -> 477 ns/op (+12% vs main). 2. The constructor was evaluating `cachedData ? cachedData.X : undefined` once per cached-data field (five separate ternaries). Replace with a single branch on `cachedData` so construction pays one conditional instead of five. Local --no-opt: `new CachedSource(new RawSource(…))` drops 431 -> 375 ns/op (+13% vs main), erasing the -11% regression CodSpeed showed on `cached-source: new CachedSource()`. `_getCachedSource()` stays on the class because `buffer()`, `streamChunks()` and `getCachedData()` still call it; only `source()` had a hot enough caller to justify duplicating the body. https://claude.ai/code/session_01LZbaaPrnDTu6y7s4nK4cJz
diff --git a/lib/CachedSource.js b/lib/CachedSource.js
@@ -127,36 +127,48 @@ class CachedSource extends Source {
 		 * @type {Source | (() => Source)}
 		 */
 		this._source = source;
-		/**
-		 * @private
-		 * @type {boolean | undefined}
-		 */
-		this._cachedSourceType = cachedData ? cachedData.source : undefined;
 		/**
 		 * @private
 		 * @type {undefined | string}
 		 */
 		this._cachedSource = undefined;
-		/**
-		 * @private
-		 * @type {Buffer | undefined}
-		 */
-		this._cachedBuffer = cachedData ? cachedData.buffer : undefined;
-		/**
-		 * @private
-		 * @type {number | undefined}
-		 */
-		this._cachedSize = cachedData ? cachedData.size : undefined;
-		/**
-		 * @private
-		 * @type {BufferedMaps}
-		 */
-		this._cachedMaps = cachedData ? cachedData.maps : new Map();
-		/**
-		 * @private
-		 * @type {(string | Buffer)[] | undefined}
-		 */
-		this._cachedHashUpdate = cachedData ? cachedData.hash : undefined;
+		// Split on `cachedData` once instead of re-evaluating the ternary for
+		// every field. Under the interpreter (and CodSpeed's simulation) each
+		// ternary is a separate branch; consolidating cuts the per-instance
+		// branch count roughly in half.
+		if (cachedData) {
+			/**
+			 * @private
+			 * @type {boolean | undefined}
+			 */
+			this._cachedSourceType = cachedData.source;
+			/**
+			 * @private
+			 * @type {Buffer | undefined}
+			 */
+			this._cachedBuffer = cachedData.buffer;
+			/**
+			 * @private
+			 * @type {number | undefined}
+			 */
+			this._cachedSize = cachedData.size;
+			/**
+			 * @private
+			 * @type {BufferedMaps}
+			 */
+			this._cachedMaps = cachedData.maps;
+			/**
+			 * @private
+			 * @type {(string | Buffer)[] | undefined}
+			 */
+			this._cachedHashUpdate = cachedData.hash;
+		} else {
+			this._cachedSourceType = undefined;
+			this._cachedBuffer = undefined;
+			this._cachedSize = undefined;
+			this._cachedMaps = new Map();
+			this._cachedHashUpdate = undefined;
+		}
 	}
 
 	/**
@@ -212,12 +224,21 @@ class CachedSource extends Source {
 	 * @returns {SourceValue} source
 	 */
 	source() {
-		// Inline the hot warm-cache check so the common case avoids a
-		// `_getCachedSource()` call and its prototype-method lookup. Falling
-		// back to the shared helper handles the rarer buffer-derived path.
+		// Fully inlined _getCachedSource: both warm- and cold-cache paths skip
+		// the prototype method lookup / stack frame the interpreter would
+		// otherwise pay on every call.
 		if (this._cachedSource !== undefined) return this._cachedSource;
-		const source = this._getCachedSource();
-		if (source !== undefined) return source;
+		const cachedBuffer = this._cachedBuffer;
+		const cachedSourceType = this._cachedSourceType;
+		if (cachedBuffer !== undefined && cachedSourceType !== undefined) {
+			const value = cachedSourceType
+				? cachedBuffer.toString("utf8")
+				: cachedBuffer;
+			if (isDualStringBufferCachingEnabled()) {
+				this._cachedSource = /** @type {string} */ (value);
+			}
+			return /** @type {string} */ (value);
+		}
 		return (this._cachedSource =
 			/** @type {string} */
 			(this.original().source()));
