crypto: streamline WebIDL dictionary converter hot loop

Simplify the generated dictionary converter's per-call work: classify V
with `typeof` instead of `type()`, hoist `opts.prefix`/`opts.context`
and `allMembers.length` out of the loop, and initialize `allMembers`
with direct index assignment instead of `ArrayPrototypePush`.

Also drops the now-unused `type()` helper.

Signed-off-by: Filip Skokan <panva.ip@gmail.com>

Author: panva

lib/internal/crypto/webidl.js

@@ -13,7 +13,6 @@
 const {
   ArrayBufferIsView,
   ArrayPrototypeIncludes,
-  ArrayPrototypePush,
   ArrayPrototypeSort,
   MathPow,
   MathTrunc,
@@ -67,37 +66,7 @@ function toNumber(value, opts = kEmptyObject) {
   }
 }
 
-function type(V) {
-  if (V === null)
-    return 'Null';
-
-  switch (typeof V) {
-    case 'undefined':
-      return 'Undefined';
-    case 'boolean':
-      return 'Boolean';
-    case 'number':
-      return 'Number';
-    case 'string':
-      return 'String';
-    case 'symbol':
-      return 'Symbol';
-    case 'bigint':
-      return 'BigInt';
-    case 'object': // Fall through
-    case 'function': // Fall through
-    default:
-      // Per ES spec, typeof returns an implementation-defined value that is not
-      // any of the existing ones for uncallable non-standard exotic objects.
-      // Yet Type() which the Web IDL spec depends on returns Object for such
-      // cases. So treat the default case as an object.
-      return 'Object';
-  }
-}
-
 // Fast check for the WebIDL Object type: a non-null object or a function.
-// Equivalent to `type(V) === 'Object'` but avoids allocating and comparing
-// the intermediate string tag on hot paths.
 function isObjectType(V) {
   return V !== null && (typeof V === 'object' || typeof V === 'function');
 }
@@ -251,61 +220,59 @@ function createDictionaryConverter(name, dictionaries) {
     if (member.required) {
       hasRequiredKey = true;
     }
-    ArrayPrototypePush(allMembers, member);
+    allMembers[i] = member;
   }
   ArrayPrototypeSort(allMembers, (a, b) => {
     if (a.key === b.key) {
       return 0;
     }
     return a.key < b.key ? -1 : 1;
   });
+  const membersLength = allMembers.length;
 
   return function(V, opts = kEmptyObject) {
-    const typeV = type(V);
-    switch (typeV) {
-      case 'Undefined':
-      case 'Null':
-      case 'Object':
-        break;
-      default:
-        throw makeException(
-          'can not be converted to a dictionary',
-          opts);
+    let isNullish;
+    if (V === undefined || V === null) {
+      isNullish = true;
+    } else if (typeof V === 'object' || typeof V === 'function') {
+      isNullish = false;
+    } else {
+      throw makeException(
+        'can not be converted to a dictionary',
+        opts);
     }
-    const esDict = V;
+
     const idlDict = {};
 
     // Fast path null and undefined.
-    if (V == null && !hasRequiredKey) {
+    if (isNullish && !hasRequiredKey) {
       return idlDict;
     }
 
-    for (let i = 0; i < allMembers.length; i++) {
+    const prefix = opts.prefix;
+    const outerContext = opts.context;
+
+    for (let i = 0; i < membersLength; i++) {
       const member = allMembers[i];
       const key = member.key;
 
-      let esMemberValue;
-      if (typeV === 'Undefined' || typeV === 'Null') {
-        esMemberValue = undefined;
-      } else {
-        esMemberValue = esDict[key];
-      }
+      const esMemberValue = isNullish ? undefined : V[key];
 
       if (esMemberValue !== undefined) {
-        const context = `'${key}' of '${name}'${
-          opts.context ? ` (${opts.context})` : ''
-        }`;
+        const context = outerContext ?
+          `'${key}' of '${name}' (${outerContext})` :
+          `'${key}' of '${name}'`;
         const idlMemberValue = member.converter(esMemberValue, {
           __proto__: null,
-          prefix: opts.prefix,
+          prefix,
           context,
         });
-        member.validator?.(idlMemberValue, esDict);
+        member.validator?.(idlMemberValue, V);
         setOwnProperty(idlDict, key, idlMemberValue);
       } else if (member.required) {
         throw makeException(
           `can not be converted to '${name}' because '${key}' is required in '${name}'.`,
-          { __proto__: null, prefix: opts.prefix, context: opts.context, code: 'ERR_MISSING_OPTION' });
+          { __proto__: null, prefix, context: outerContext, code: 'ERR_MISSING_OPTION' });
       }
     }