fixup! lib: refactor internal webidl converters

Author: panva

benchmark/misc/webidl-convert-to-int.js

@@ -5,6 +5,7 @@ const common = require('../common.js');
 
 const bench = common.createBenchmark(main, {
   converter: [
+    'byte',
     'octet',
     'unsigned short',
     'unsigned long',
@@ -23,6 +24,8 @@ const bench = common.createBenchmark(main, {
 
 function getConverter(converter) {
   switch (converter) {
+    case 'byte':
+      return { bitLength: 8, signedness: 'signed' };
     case 'octet':
       return { bitLength: 8 };
     case 'unsigned short':

lib/internal/webidl.js

@@ -386,7 +386,6 @@ function convertToInt(
       if (V >= upperBound) {
         return upperBound === 0 ? 0 : upperBound;
       }
-      return evenRound(V);
     }
     x = V;
   } else {
@@ -623,15 +622,24 @@ function createEnumConverter(name, values) {
 
 /**
  * Returns the context used when converting a dictionary member.
- * @param {string} dictionaryName Dictionary identifier.
  * @param {string} key Dictionary member identifier.
  * @param {ConversionOptions} options Conversion options.
  * @returns {string}
  */
-function dictionaryMemberContext(dictionaryName, key, options) {
+function dictionaryMemberContext(key, options) {
   return options.context ? `${key} in ${options.context}` : key;
 }
 
+/**
+ * Returns the context used when converting a sequence element.
+ * @param {number} index Sequence element index.
+ * @param {ConversionOptions} options Conversion options.
+ * @returns {string}
+ */
+function sequenceElementContext(index, options) {
+  return `${options.context ?? 'Value'}[${index}]`;
+}
+
 /**
  * Returns the message used for a missing required dictionary member.
  * @param {string} dictionaryName Dictionary identifier.
@@ -692,7 +700,7 @@ function createDictionaryConverter(
           {
             __proto__: null,
             ...options,
-            context: dictionaryMemberContext(dictionaryName, key, options),
+            context: dictionaryMemberContext(key, options),
           },
         );
         // Validators are a Node.js extension after conversion. They let
@@ -770,7 +778,7 @@ function createSequenceConverter(converter) {
       const idlValue = converter(next.value, {
         __proto__: null,
         ...options,
-        context: `${options.context}[${idlSequence.length}]`,
+        context: sequenceElementContext(idlSequence.length, options),
       });
       // Step 3.4: store the value and advance i.
       ArrayPrototypePush(idlSequence, idlValue);
@@ -823,6 +831,7 @@ function validateBufferSourceBacking(buffer, options) {
     // ArrayBuffer.prototype.resizable is an ArrayBuffer brand check and the
     // [AllowResizable] value we need. For SharedArrayBuffer-backed views it
     // throws, which lets this path avoid a separate IsSharedArrayBuffer check.
+    // Keep this in sync with the inlined BufferSource view branch below.
     resizable = ArrayBufferPrototypeGetResizable(buffer);
   } catch {
     // ArrayBufferView conversion step 2: reject SharedArrayBuffer
@@ -921,6 +930,7 @@ converters.BufferSource = (V, options = kEmptyObject) => {
     // Keep this logic inline instead of calling validateBufferSourceBacking().
     // BufferSource conversion is hot, and this avoids a helper call while still
     // using a primordial getter for the backing-buffer internal-slot check.
+    // Keep this in sync with validateBufferSourceBacking().
     let resizable;
     try {
       // ArrayBuffer.prototype.resizable is both the ArrayBuffer brand check

test/parallel/test-blob.js

@@ -157,6 +157,22 @@ assert.throws(() => new Blob({}), {
   assert.strictEqual(b.type, '');
 }
 
+{
+  const b = new Blob(['hello']);
+
+  assert.throws(() => b.slice(1n), {
+    name: 'TypeError',
+    code: 'ERR_INVALID_ARG_TYPE',
+    message: 'start is a BigInt and cannot be converted to a number.',
+  });
+
+  assert.throws(() => b.slice(0, Symbol()), {
+    name: 'TypeError',
+    code: 'ERR_INVALID_ARG_TYPE',
+    message: 'end is a Symbol and cannot be converted to a number.',
+  });
+}
+
 {
   const b = new Blob([Buffer.from('hello'), Buffer.from('world')]);
   const mc = new MessageChannel();

test/parallel/test-internal-webidl.js

@@ -377,11 +377,24 @@ assert.throws(() => webidl.requiredArguments(1, 2, opts), {
   const converter = converters['sequence<DOMString>'];
   assert.deepStrictEqual(converter([1, 2]), ['1', '2']);
 
+  assert.throws(() => converter([Symbol()]), {
+    name: 'TypeError',
+    code: 'ERR_INVALID_ARG_TYPE',
+    message: 'Value[0] is a Symbol and cannot be converted to a string.',
+  });
+
   assert.throws(() => converter({ [Symbol.iterator]: 1 }, opts), {
     name: 'TypeError',
     code: 'ERR_INVALID_ARG_TYPE',
     message: 'Prefix: Context cannot be converted to sequence.',
   });
+
+  assert.throws(() => converter([Symbol()], opts), {
+    name: 'TypeError',
+    code: 'ERR_INVALID_ARG_TYPE',
+    message: 'Prefix: Context[0] is a Symbol and cannot be converted ' +
+      'to a string.',
+  });
 }
 
 {

test/parallel/test-performance-resourcetimingbuffersize.js

@@ -37,6 +37,19 @@ async function main() {
     globalThis,
     cacheMode,
   ];
+
+  assert.throws(() => performance.setResourceTimingBufferSize(1n), {
+    name: 'TypeError',
+    code: 'ERR_INVALID_ARG_TYPE',
+    message: 'maxSize is a BigInt and cannot be converted to a number.',
+  });
+
+  assert.throws(() => performance.setResourceTimingBufferSize(Symbol()), {
+    name: 'TypeError',
+    code: 'ERR_INVALID_ARG_TYPE',
+    message: 'maxSize is a Symbol and cannot be converted to a number.',
+  });
+
   // Invalid buffer size values are converted to 0.
   const invalidValues = [ null, undefined, true, false, -1, 0.5, Infinity, NaN, '', 'foo', {}, [], () => {} ];
   for (const value of invalidValues) {

test/parallel/test-webcrypto-webidl.js

@@ -228,15 +228,27 @@ function assertJsonWebKey(actual, expected) {
     assert.deepStrictEqual(converters.BufferSource(resizable), resizable);
     assert.deepStrictEqual(converters.BufferSource(view), view);
     assert.deepStrictEqual(converters.BufferSource(dataView), dataView);
+    const resizableError = {
+      name: 'TypeError',
+      code: 'ERR_INVALID_ARG_TYPE',
+      message: `${prefix}: ${context} is backed by a resizable ` +
+        'ArrayBuffer, which is not allowed.',
+    };
     assert.throws(() => converters.BufferSource(resizable, {
       __proto__: null,
       ...opts,
       allowResizable: false,
-    }), {
-      name: 'TypeError',
-      code: 'ERR_INVALID_ARG_TYPE',
-      message: `${prefix}: ${context} is backed by a resizable ArrayBuffer, which is not allowed.`
-    });
+    }), resizableError);
+    assert.throws(() => converters.BufferSource(view, {
+      __proto__: null,
+      ...opts,
+      allowResizable: false,
+    }), resizableError);
+    assert.throws(() => converters.BufferSource(dataView, {
+      __proto__: null,
+      ...opts,
+      allowResizable: false,
+    }), resizableError);
   }
 }