util: fix inspecting of proxy objects

In certain conditions, inspecting a Proxy object can lead to a
max call stack error. Avoid that by detecting the Proxy object
and outputting information about the Proxy object itself.

Also adds util.isProxy()

Fixes: nodejs#6464

doc/api/util.md

@@ -478,6 +478,22 @@ util.isPrimitive(new Date())
   // false
 ```
 
+## util.isProxy(object)
+
+Returns `true` if the given "object" is a `Proxy` object. Otherwise, returns
+`false`.
+
+```js
+const util = require('util');
+const proxyObj = new Proxy({}, {get: () => { return 5; }});
+
+util.isProxy(proxyObj);
+  // true
+
+util.isProxy({});
+  // false
+```
+
 ## util.isRegExp(object)
 
     Stability: 0 - Deprecated

lib/util.js

@@ -241,6 +241,13 @@ function inspectPromise(p) {
 
 
 function formatValue(ctx, value, recurseTimes) {
+
+  if (isProxy(value)) {
+    return 'Proxy ' + formatValue(ctx,
+                                  binding.getProxyDetails(value),
+                                  recurseTimes);
+  }
+
   // Provide a hook for user-specified inspect functions.
   // Check that value is an object with an inspect function on it
   if (ctx.customInspect &&
@@ -785,6 +792,10 @@ exports.isPrimitive = isPrimitive;
 
 exports.isBuffer = Buffer.isBuffer;
 
+function isProxy(p) {
+  return binding.isProxy(p);
+}
+exports.isProxy = isProxy;
 
 function pad(n) {
   return n < 10 ? '0' + n.toString(10) : n.toString(10);

src/env.h

@@ -121,6 +121,7 @@ namespace node {
   V(fsevent_string, "FSEvent")                                                \
   V(gid_string, "gid")                                                        \
   V(handle_string, "handle")                                                  \
+  V(handler_string, "handler")                                                \
   V(heap_total_string, "heapTotal")                                           \
   V(heap_used_string, "heapUsed")                                             \
   V(homedir_string, "homedir")                                                \
@@ -222,6 +223,7 @@ namespace node {
   V(subjectaltname_string, "subjectaltname")                                  \
   V(sys_string, "sys")                                                        \
   V(syscall_string, "syscall")                                                \
+  V(target_string, "target")                                                  \
   V(tick_callback_string, "_tickCallback")                                    \
   V(tick_domain_cb_string, "_tickDomainCallback")                             \
   V(ticketkeycallback_string, "onticketkeycallback")                          \

src/node_util.cc

@@ -11,6 +11,7 @@ using v8::FunctionCallbackInfo;
 using v8::Local;
 using v8::Object;
 using v8::Private;
+using v8::Proxy;
 using v8::String;
 using v8::Value;
 
@@ -22,6 +23,7 @@ using v8::Value;
   V(isMap, IsMap)                                                             \
   V(isMapIterator, IsMapIterator)                                             \
   V(isPromise, IsPromise)                                                     \
+  V(isProxy, IsProxy)                                                         \
   V(isRegExp, IsRegExp)                                                       \
   V(isSet, IsSet)                                                             \
   V(isSetIterator, IsSetIterator)                                             \
@@ -37,6 +39,21 @@ using v8::Value;
   VALUE_METHOD_MAP(V)
 #undef V
 
+static void GetProxyDetails(const FunctionCallbackInfo<Value>& args) {
+  Environment* env = Environment::GetCurrent(args);
+
+  // Return nothing if it's not a proxy.
+  if (!args[0]->IsProxy())
+    return;
+
+  Local<Proxy> proxy = args[0].As<Proxy>();
+
+  Local<Object> ret = Object::New(env->isolate());
+  ret->Set(env->handler_string(), proxy->GetHandler());
+  ret->Set(env->target_string(), proxy->GetTarget());
+
+  args.GetReturnValue().Set(ret);
+}
 
 static void GetHiddenValue(const FunctionCallbackInfo<Value>& args) {
   Environment* env = Environment::GetCurrent(args);
@@ -84,6 +101,7 @@ void Initialize(Local<Object> target,
 
   env->SetMethod(target, "getHiddenValue", GetHiddenValue);
   env->SetMethod(target, "setHiddenValue", SetHiddenValue);
+  env->SetMethod(target, "getProxyDetails", GetProxyDetails);
 }
 
 }  // namespace util

test/parallel/test-util-inspect-proxy.js

@@ -0,0 +1,29 @@
+'use strict';
+
+require('../common');
+const assert = require('assert');
+const util = require('util');
+const processUtil = process.binding('util');
+
+const target = {};
+const handler = {
+  get: function() { throw new Error('Getter should not be called'); }
+};
+const proxyObj = new Proxy(target, handler);
+
+assert.strictEqual(util.isProxy(proxyObj), true);
+
+// Inspecting the proxy should not actually walk it's properties
+assert.doesNotThrow(() => util.inspect(proxyObj));
+
+const details = processUtil.getProxyDetails(proxyObj);
+assert.deepStrictEqual(target, details.target);
+assert.deepStrictEqual(handler, details.handler);
+
+assert.strictEqual(util.inspect(proxyObj),
+    'Proxy { handler: { get: [Function] }, target: {} }');
+
+// Using getProxyDetails with non-proxy returns undefined
+assert.strictEqual(processUtil.getProxyDetails({}), undefined);
+// isProxy with non-Proxy returns false
+assert.strictEqual(util.isProxy({}), false);