repl: fix crash with large buffer tab completion

lib/repl.js

@@ -57,6 +57,7 @@ const Module = require('module');
 const domain = require('domain');
 const debug = util.debuglog('repl');
 const errors = require('internal/errors');
+const Buffer = require('buffer').Buffer;
 
 const parentModule = module;
 const replMap = new WeakMap();
@@ -689,8 +690,71 @@ function intFilter(item) {
   return /^[A-Za-z_$]/.test(item);
 }
 
+const defaultProperties = [
+  [ Array, Object.getOwnPropertyNames([]).filter(intFilter) ],
+  [ Buffer, Object.getOwnPropertyNames(Buffer.alloc(0)).filter(intFilter) ],
+
+  [ Uint8Array,
+    Object.getOwnPropertyNames(new Uint8Array()).filter(intFilter) ],
+  [ Uint16Array,
+    Object.getOwnPropertyNames(new Uint16Array()).filter(intFilter) ],
+  [ Uint32Array,
+    Object.getOwnPropertyNames(new Uint32Array()).filter(intFilter) ],
+  [
+    Uint8ClampedArray,
+    Object.getOwnPropertyNames(new Uint8ClampedArray()).filter(intFilter) ],
+  [ Int8Array,
+    Object.getOwnPropertyNames(new Int8Array()).filter(intFilter) ],
+  [ Int16Array,
+    Object.getOwnPropertyNames(new Int16Array()).filter(intFilter) ],
+  [ Int32Array,
+    Object.getOwnPropertyNames(new Int32Array()).filter(intFilter) ],
+  [ Float32Array,
+    Object.getOwnPropertyNames(new Float32Array()).filter(intFilter) ],
+  [ Float64Array,
+    Object.getOwnPropertyNames(new Float64Array()).filter(intFilter) ]
+];
+const ARRAY_LENGTH_THRESHOLD = 1e6;
+
+function mayBeLargeObject(obj) {
+  // `Buffer.prototype` passes the `Buffer.isBuffer` and
+  // `instanceof Uint8Array`.
+  //
+  // Refs: https://github.com/nodejs/node/pull/11961
+  if (obj === Buffer.prototype) return null;
+
+  for (const type of defaultProperties) {
+    var typeMatch;
+    if (type[0] === Array) {
+      typeMatch = Array.isArray(obj);
+    } else if (type[0] === Buffer) {
+      typeMatch = Buffer.isBuffer(obj);
+    } else {
+      typeMatch = obj instanceof type[0];
+    }
+
+    if (typeMatch) {
+      return obj.length > ARRAY_LENGTH_THRESHOLD ? type[1] : null;
+    }
+  }
+  return null;
+}
+
 function filteredOwnPropertyNames(obj) {
   if (!obj) return [];
+  const fakeProperties = mayBeLargeObject(obj);
+  if (fakeProperties !== null) {
+    this._writeToOutput('\r\n');
+    process.emitWarning(
+      'Instance is too large so the completion may missing some custom ' +
+      'properties.',
+      'REPLWarning',
+      undefined,
+      undefined,
+      true);
+
+    return fakeProperties;
+  }
   return Object.getOwnPropertyNames(obj).filter(intFilter);
 }
 
@@ -843,9 +907,11 @@ function complete(line, callback) {
         if (this.useGlobal || vm.isContext(this.context)) {
           var contextProto = this.context;
           while (contextProto = Object.getPrototypeOf(contextProto)) {
-            completionGroups.push(filteredOwnPropertyNames(contextProto));
+            completionGroups.push(
+              filteredOwnPropertyNames.call(this, contextProto));
           }
-          completionGroups.push(filteredOwnPropertyNames(this.context));
+          completionGroups.push(
+            filteredOwnPropertyNames.call(this, this.context));
           addStandardGlobals(completionGroups, filter);
           completionGroupsLoaded();
         } else {
@@ -865,13 +931,13 @@ function complete(line, callback) {
         }
       } else {
         const evalExpr = `try { ${expr} } catch (e) {}`;
-        this.eval(evalExpr, this.context, 'repl', function doEval(e, obj) {
+        this.eval(evalExpr, this.context, 'repl', (e, obj) => {
           // if (e) console.log(e);
 
           if (obj != null) {
             if (typeof obj === 'object' || typeof obj === 'function') {
               try {
-                memberGroups.push(filteredOwnPropertyNames(obj));
+                memberGroups.push(filteredOwnPropertyNames.call(this, obj));
               } catch (ex) {
                 // Probably a Proxy object without `getOwnPropertyNames` trap.
                 // We simply ignore it here, as we don't want to break the
@@ -889,7 +955,7 @@ function complete(line, callback) {
                 p = obj.constructor ? obj.constructor.prototype : null;
               }
               while (p !== null) {
-                memberGroups.push(filteredOwnPropertyNames(p));
+                memberGroups.push(filteredOwnPropertyNames.call(this, p));
                 p = Object.getPrototypeOf(p);
                 // Circular refs possible? Let's guard against that.
                 sentinel--;

test/parallel/test-repl-tab-complete.js

@@ -305,6 +305,68 @@ testMe.complete('.b', common.mustCall((error, data) => {
   assert.deepStrictEqual(data, [['break'], 'b']);
 }));
 
+// tab completion for large buffer
+const warningRegEx =
+  /\(node:\d+\) REPLWarning: Instance is too large so the completion may missing some custom properties\./;
+[
+  Array,
+  Buffer,
+
+  Uint8Array,
+  Uint16Array,
+  Uint32Array,
+
+  Uint8ClampedArray,
+  Int8Array,
+  Int16Array,
+  Int32Array,
+  Float32Array,
+  Float64Array,
+].forEach((type) => {
+  putIn.run(['.clear']);
+
+  if (type === Array) {
+    putIn.run([
+      'var ele = [];',
+      'for (let i = 0; i < 1e6 + 1; i++) ele[i] = 0;',
+      'ele.biu = 1;'
+    ]);
+  } else if (type === Buffer) {
+    putIn.run(['var ele = Buffer.alloc(1e6 + 1); ele.biu = 1;']);
+  } else {
+    putIn.run([`var ele = new ${type.name}(1e6 + 1); ele.biu = 1;`]);
+  }
+
+  common.hijackStderr(common.mustCall((err) => {
+    process.nextTick(() => {
+      assert.ok(warningRegEx.test(err));
+    });
+  }));
+  testMe.complete('ele.', common.mustCall((err, data) => {
+    common.restoreStderr();
+    assert.ifError(err);
+
+    const ele = (type === Array) ?
+      [] :
+      (type === Buffer ?
+        Buffer.alloc(0) :
+        new type(0));
+
+    data[0].forEach((key) => {
+      if (!key) return;
+      assert.notStrictEqual(ele[key.substr(4)], undefined);
+    });
+
+    // no `biu`
+    assert.strictEqual(data.indexOf('ele.biu'), -1);
+  }));
+});
+
+// check Buffer.prototype.length not crashing.
+// Refs: Refs: https://github.com/nodejs/node/pull/11961
+putIn.run['.clear'];
+testMe.complete('Buffer.prototype.', common.mustCall());
+
 const testNonGlobal = repl.start({
   input: putIn,
   output: putIn,