buffer: support boxed strings and toPrimitive

Add support for `Buffer.from(new String('...'))` and `Buffer.from({[Symbol.toPrimitive](){return '...'}})` PR-URL: #13725 Reviewed-By: Anna Henningsen <[email protected]> Reviewed-By: Refael Ackermann <[email protected]> Reviewed-By: Colin Ihrig <[email protected]>

Author: jasnell

doc/api/buffer.md

@@ -908,6 +908,44 @@ console.log(buf2.toString());
 
 A `TypeError` will be thrown if `str` is not a string.
 
+### Class Method: Buffer.from(object[, offsetOrEncoding[, length]])
+<!-- YAML
+added: REPLACEME
+-->
+
+*`object`{Object} An object supporting `Symbol.toPrimitive` or `valueOf()`
+*`offsetOrEncoding`{number|string} A byte-offset or encoding, depending on
+ the value returned either by `object.valueOf()` or
+`object[Symbol.toPrimitive]()`.
+*`length`{number} A length, depending on the value returned either by
+`object.valueOf()` or `object[Symbol.toPrimitive]()`.
+
+For objects whose `valueOf()` function returns a value not strictly equal to
+`object`, returns `Buffer.from(object.valueOf(), offsetOrEncoding, length)`.
+
+For example:
+
+```js
+constbuf=Buffer.from(newString('this is a test'));
+// <Buffer 74 68 69 73 20 69 73 20 61 20 74 65 73 74>
+```
+
+For objects that support `Symbol.toPrimitive`, returns
+`Buffer.from(object[Symbol.toPrimitive](), offsetOrEncoding, length)`.
+
+For example:
+
+```js
+classFoo{
+ [Symbol.toPrimitive](){
+return'this is a test';
+ }
+}
+
+constbuf=Buffer.from(newFoo(), 'utf8');
+// <Buffer 74 68 69 73 20 69 73 20 61 20 74 65 73 74>
+```
+
 ### Class Method: Buffer.isBuffer(obj)
 <!-- YAML
 added: v0.1.101

lib/buffer.js

@@ -175,12 +175,26 @@ Buffer.from = function(value, encodingOrOffset, length){
 if(isAnyArrayBuffer(value))
 returnfromArrayBuffer(value,encodingOrOffset,length);
 
+if(value==null)
+thrownewTypeError(kFromErrorMsg);
+
+if(typeofvalue==='number')
+thrownewTypeError('"value" argument must not be a number');
+
+constvalueOf=value.valueOf&&value.valueOf();
+if(valueOf!=null&&valueOf!==value)
+returnBuffer.from(valueOf,encodingOrOffset,length);
+
 varb=fromObject(value);
 if(b)
 returnb;
 
-if(typeofvalue==='number')
-thrownewTypeError('"value" argument must not be a number');
+if(typeofvalue[Symbol.toPrimitive]==='function'){
+returnBuffer.from(value[Symbol.toPrimitive]('string'),
+encodingOrOffset,
+length);
+}
+
 thrownewTypeError(kFromErrorMsg);
 };
 

test/parallel/test-buffer-from.js

@@ -0,0 +1,57 @@
+'use strict';
+
+require('../common');
+const{ deepStrictEqual, throws }=require('assert');
+const{ Buffer }=require('buffer');
+const{ runInNewContext }=require('vm');
+
+constcheckString='test';
+
+constcheck=Buffer.from(checkString);
+
+classMyStringextendsString{
+constructor(){
+super(checkString);
+}
+}
+
+classMyPrimitive{
+[Symbol.toPrimitive](){
+returncheckString;
+}
+}
+
+classMyBadPrimitive{
+[Symbol.toPrimitive](){
+return1;
+}
+}
+
+deepStrictEqual(Buffer.from(newString(checkString)),check);
+deepStrictEqual(Buffer.from(newMyString()),check);
+deepStrictEqual(Buffer.from(newMyPrimitive()),check);
+deepStrictEqual(Buffer.from(
+runInNewContext('new String(checkString)',{checkString})),
+check);
+
+consterr=newRegExp('^TypeError: First argument must be a string, Buffer, '+
+'ArrayBuffer, Array, or array-like object\\.$');
+
+[
+{},
+newBoolean(true),
+{valueOf(){returnnull;}},
+{valueOf(){returnundefined;}},
+{valueOf: null},
+Object.create(null)
+].forEach((input)=>{
+throws(()=>Buffer.from(input),err);
+});
+
+[
+newNumber(true),
+newMyBadPrimitive()
+].forEach((input)=>{
+throws(()=>Buffer.from(input),
+/^TypeError:"value"argumentmustnotbeanumber$/);
+});