From ef4e8d39457ab6a1e62918e89982405e68e3ff57 Mon Sep 17 00:00:00 2001
From: Ruben Bridgewater <ruben@bridgewater.de>
Date: Mon, 14 May 2018 19:50:45 +0200
Subject: [PATCH 1/2] util: recover from maximum call stack size

Using util.inspect should still return values in case the maximum
call stack size is reached. This is important to inspect linked
lists and similar.
---
 doc/api/util.md                    |  9 +++++++--
 lib/util.js                        | 22 ++++++++++++++++++++--
 test/parallel/test-util-inspect.js | 21 +++++++++++++++++----
 3 files changed, 44 insertions(+), 8 deletions(-)

diff --git a/doc/api/util.md b/doc/api/util.md
index db0790f7ea281b..4a6988c87d0f93 100644
--- a/doc/api/util.md
+++ b/doc/api/util.md
@@ -360,6 +360,10 @@ stream.write('With ES6');
 <!-- YAML
 added: v0.3.0
 changes:
+  - version: REPLACEME
+    pr-url: https://github.com/nodejs/node/pull/REPLACEME
+    description: Inspecting linked lists and similar objects is now possible
+                 up to the maximum call stack size.
   - version: v10.0.0
     pr-url: https://github.com/nodejs/node/pull/19259
     description: The `WeakMap` and `WeakSet` entries can now be inspected
@@ -388,8 +392,9 @@ changes:
     properties will be included in the formatted result as well as [`WeakMap`][]
     and [`WeakSet`][] entries. **Default:** `false`.
   * `depth` {number} Specifies the number of times to recurse while formatting
-    the `object`. This is useful for inspecting large complicated objects.
-    To make it recurse indefinitely pass `null`. **Default:** `2`.
+    the `object`. This is useful for inspecting large complicated objects. To
+    make it recurse up to the maximum call stack size pass `Infinity` or `null`.
+    **Default:** `2`.
   * `colors` {boolean} If `true`, the output will be styled with ANSI color
     codes. Colors are customizable, see [Customizing `util.inspect` colors][].
     **Default:** `false`.
diff --git a/lib/util.js b/lib/util.js
index f8845e4153947b..73f0076f6ae840 100644
--- a/lib/util.js
+++ b/lib/util.js
@@ -701,14 +701,32 @@ function formatValue(ctx, value, recurseTimes) {
   }
 
   ctx.seen.push(value);
-  const output = formatter(ctx, value, recurseTimes, keys);
-
+  let output;
+  // This corresponds to a depth of at least 333 and likely 500.
+  if (ctx.indentationLvl < 1000) {
+    output = formatter(ctx, value, recurseTimes, keys);
+  } else {
+    try {
+      output = formatter(ctx, value, recurseTimes, keys);
+    } catch (err) {
+      if (errors.isStackOverflowError(err)) {
+        ctx.seen.pop();
+        process.emitWarning(
+          'Inspection reached the maximum call stack size. Incomplete ' +
+          'inspected object returned.'
+        );
+        return ctx.stylize(`[${constructor || tag || 'Object'}]`, 'special');
+      }
+      throw err;
+    }
+  }
   if (extra !== undefined)
     output.unshift(extra);
 
   for (var i = 0; i < symbols.length; i++) {
     output.push(formatProperty(ctx, value, recurseTimes, symbols[i], 0));
   }
+
   ctx.seen.pop();
 
   return reduceToSingleString(ctx, output, base, braces);
diff --git a/test/parallel/test-util-inspect.js b/test/parallel/test-util-inspect.js
index 347f5046a832b2..bd513ab05cb756 100644
--- a/test/parallel/test-util-inspect.js
+++ b/test/parallel/test-util-inspect.js
@@ -1410,10 +1410,23 @@ util.inspect(process);
   // Test that a long linked list can be inspected without throwing an error.
   const list = {};
   let head = list;
-  // The real cutoff value is closer to 1400 stack frames as of May 2018,
-  // but let's be generous here – even a linked listed of length 100k should be
-  // inspectable in some way.
+  // A linked list of length 100k should be inspectable in some way, even though
+  // the real cutoff value is much lower than 100k.
   for (let i = 0; i < 100000; i++)
     head = head.next = {};
-  util.inspect(list);
+  assert.strictEqual(
+    util.inspect(list),
+    '{ next: { next: { next: [Object] } } }'
+  );
+  common.expectWarning({
+    Warning: [
+      'Inspection reached the maximum call stack size. ' +
+        'Incomplete inspected object returned.',
+      common.noWarnCode
+    ]
+  });
+  const longList = util.inspect(list, { depth: Infinity });
+  const match = longList.match(/next/g);
+  assert(match.length > 1000 && match.length < 10000);
+  assert(longList.includes('[Object]'));
 }

From 7748619dcfa120639f871158d9063fe2241fd3c9 Mon Sep 17 00:00:00 2001
From: Ruben Bridgewater <ruben@bridgewater.de>
Date: Mon, 11 Jun 2018 03:02:12 +0200
Subject: [PATCH 2/2] fixup: add requested change

---
 lib/util.js                        |  8 ++++----
 test/parallel/test-util-inspect.js | 10 ++--------
 2 files changed, 6 insertions(+), 12 deletions(-)

diff --git a/lib/util.js b/lib/util.js
index 73f0076f6ae840..f24430d791f7c6 100644
--- a/lib/util.js
+++ b/lib/util.js
@@ -711,11 +711,11 @@ function formatValue(ctx, value, recurseTimes) {
     } catch (err) {
       if (errors.isStackOverflowError(err)) {
         ctx.seen.pop();
-        process.emitWarning(
-          'Inspection reached the maximum call stack size. Incomplete ' +
-          'inspected object returned.'
+        return ctx.stylize(
+          `[${constructor || tag || 'Object'}: Inspection interrupted ` +
+            'prematurely. Maximum call stack size exceeded.]',
+          'special'
         );
-        return ctx.stylize(`[${constructor || tag || 'Object'}]`, 'special');
       }
       throw err;
     }
diff --git a/test/parallel/test-util-inspect.js b/test/parallel/test-util-inspect.js
index bd513ab05cb756..1f05f4987eeb41 100644
--- a/test/parallel/test-util-inspect.js
+++ b/test/parallel/test-util-inspect.js
@@ -1418,15 +1418,9 @@ util.inspect(process);
     util.inspect(list),
     '{ next: { next: { next: [Object] } } }'
   );
-  common.expectWarning({
-    Warning: [
-      'Inspection reached the maximum call stack size. ' +
-        'Incomplete inspected object returned.',
-      common.noWarnCode
-    ]
-  });
   const longList = util.inspect(list, { depth: Infinity });
   const match = longList.match(/next/g);
   assert(match.length > 1000 && match.length < 10000);
-  assert(longList.includes('[Object]'));
+  assert(longList.includes('[Object: Inspection interrupted ' +
+    'prematurely. Maximum call stack size exceeded.]'));
 }