koffi 1.1.0-beta.6 → 1.1.0

package/README.md

@@ -20,10 +20,10 @@
 
 Koffi is a fast and easy-to-use FFI module for Node.js, with support for primitive and aggregate data types (structs), both by reference (pointer) and by value.
 
-After the release of version 1.0, the following features are planned:
+The following features are planned in the near future:
 
-* 1.1: Asynchronous calls and fixed-size array types
 * 1.2: C to JS callbacks
+* 1.3: Type parser
 
 The following platforms __are officially supported and tested__ at the moment:
 
@@ -231,6 +231,33 @@ Koffi exposes three functions to explore type information:
 Fixed-size arrays are declared with `koffi.array(type, length)`. Just like in C, they cannot be passed
 as functions parameters (they degenerate to pointers), or returned by value. You can however embed them in struct types.
 
+Special rules apply for arrays of primitive integer and float types (uint32_t, double, etc...):
+- When converting from JS to C, Koffi can take a normal Array (e.g. `[1, 2]`) or a TypedArray of the correct type (e.g. `Uint8Array` for an array of `uint8_t` numbers)
+- When converting from C to JS (for return value or output parameters), Koffi will by default use a TypedArray. But you can change this behavior when you create the array type with the optional hint argument: `koffi.array('uint8_t', 64, 'array')`
+
+See the example below:
+
+```js
+const koffi = require('koffi');
+
+// Those two structs are exactly the same, only the array conversion hint is different
+const Foo1 = koffi.struct('Foo', {
+    i: 'int',
+    a16: koffi.array('int16_t', 8)
+});
+const Foo2 = koffi.struct('Foo', {
+    i: 'int',
+    a16: koffi.array('int16_t', 8, 'array')
+});
+
+// Uses an hypothetical C function that just returns the struct passed as a parameter
+const ReturnFoo1 = lib.func('Foo1 ReturnFoo(Foo1 p)');
+const ReturnFoo2 = lib.func('Foo2 ReturnFoo(Foo2 p)');
+
+console.log(ReturnFoo1({ i: 5, a16: [6, 8] })) // Prints { i: 5, a16: Int16Array(2) [6, 8] }
+console.log(ReturnFoo2({ i: 5, a16: [6, 8] })) // Prints { i: 5, a16: [6, 8] }
+```
+
 ## Variadic functions
 
 Variadic functions are declared with an ellipsis as the last argument.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "koffi",
-  "version": "1.1.0-beta.6",
+  "version": "1.1.0",
   "description": "Fast and simple FFI (foreign function interface) for Node.js",
   "keywords": [
     "foreign",

package/src/call.cc

@@ -246,31 +246,38 @@ bool CallData::PushArray(const Napi::Object &obj, const TypeInfo *type, uint8_t
     if (obj.IsArray()) {
         Napi::Array array = obj.As<Napi::Array>();
 
-        if (array.Length() != len) {
+        if (RG_UNLIKELY(array.Length() != len)) {
             ThrowError<Napi::Error>(env, "Expected array of length %1, got %2", len, array.Length());
             return false;
         }
 
+#define PUSH_ARRAY(Check, Expected, GetCode) \
+            do { \
+                for (uint32_t i = 0; i < len; i++) { \
+                    Napi::Value value = array[i]; \
+                     \
+                    int16_t align = std::max(type->ref->align, realign); \
+                    dest = AlignUp(dest, align); \
+                     \
+                    if (RG_UNLIKELY(!(Check))) { \
+                        ThrowError<Napi::TypeError>(env, "Unexpected value %1 in array, expected %2", GetValueType(instance, value), (Expected)); \
+                        return false; \
+                    } \
+                     \
+                    GetCode \
+                     \
+                    dest += type->ref->size; \
+                } \
+            } while (false)
+
         switch (type->ref->primitive) {
             case PrimitiveKind::Void: { RG_UNREACHABLE(); } break;
 
             case PrimitiveKind::Bool: {
-                for (uint32_t i = 0; i < len; i++) {
-                    Napi::Value value = array[i];
-
-                    int16_t align = std::max(type->ref->align, realign);
-                    dest = AlignUp(dest, align);
-
-                    if (RG_UNLIKELY(!value.IsBoolean())) {
-                        ThrowError<Napi::TypeError>(env, "Unexpected value %1 in array, expected boolean", GetValueType(instance, value));
-                        return false;
-                    }
-
+                PUSH_ARRAY(value.IsBoolean(), "boolean", {
                     bool b = value.As<Napi::Boolean>();
                     *(bool *)dest = b;
-
-                    dest += type->ref->size;
-                }
+                });
             } break;
             case PrimitiveKind::Int8:
             case PrimitiveKind::UInt8:
@@ -280,161 +287,67 @@ bool CallData::PushArray(const Napi::Object &obj, const TypeInfo *type, uint8_t
             case PrimitiveKind::UInt32:
             case PrimitiveKind::Int64:
             case PrimitiveKind::UInt64: {
-                for (uint32_t i = 0; i < len; i++) {
-                    Napi::Value value = array[i];
-
-                    int16_t align = std::max(type->ref->align, realign);
-                    dest = AlignUp(dest, align);
-
-                    if (RG_UNLIKELY(!value.IsNumber() && !value.IsBigInt())) {
-                        ThrowError<Napi::TypeError>(env, "Unexpected value %1 in array, expected number", GetValueType(instance, value));
-                        return false;
-                    }
-
+                PUSH_ARRAY(value.IsNumber() || value.IsBigInt(), "number", {
                     int64_t v = CopyNumber<int64_t>(value);
                     memcpy(dest, &v, type->ref->size); // Little Endian
-
-                    dest += type->ref->size;
-                }
+                });
             } break;
             case PrimitiveKind::String: {
-                for (uint32_t i = 0; i < len; i++) {
-                    Napi::Value value = array[i];
-
-                    int16_t align = std::max(type->ref->align, realign);
-                    dest = AlignUp(dest, align);
-
-                    if (RG_UNLIKELY(!value.IsString())) {
-                        ThrowError<Napi::TypeError>(env, "Unexpected value %1 in array, expected string", GetValueType(instance, value));
-                        return false;
-                    }
-
+                PUSH_ARRAY(value.IsString(), "string", {
                     const char *str = PushString(value);
                     if (RG_UNLIKELY(!str))
                         return false;
                     *(const char **)dest = str;
-
-                    dest += type->ref->size;
-                }
+                });
             } break;
             case PrimitiveKind::String16: {
-                for (uint32_t i = 0; i < len; i++) {
-                    Napi::Value value = array[i];
-
-                    int16_t align = std::max(type->ref->align, realign);
-                    dest = AlignUp(dest, align);
-
-                    if (RG_UNLIKELY(!value.IsString())) {
-                        ThrowError<Napi::TypeError>(env, "Unexpected value %1 in array, expected string", GetValueType(instance, value));
-                        return false;
-                    }
-
+                PUSH_ARRAY(value.IsString(), "string", {
                     const char16_t *str16 = PushString16(value);
                     if (RG_UNLIKELY(!str16))
                         return false;
                     *(const char16_t **)dest = str16;
-
-                    dest += type->ref->size;
-                }
+                });
             } break;
             case PrimitiveKind::Pointer: {
-                for (uint32_t i = 0; i < len; i++) {
-                    Napi::Value value = array[i];
-
-                    int16_t align = std::max(type->ref->align, realign);
-                    dest = AlignUp(dest, align);
-
-                    if (RG_UNLIKELY(!CheckValueTag(instance, value, type->ref))) {
-                        ThrowError<Napi::TypeError>(env, "Unexpected value %1 in array, expected %2", GetValueType(instance, value), type->ref->name);
-                        return false;
-                    }
-
+                PUSH_ARRAY(CheckValueTag(instance, value, type->ref), type->ref->name, {
                     Napi::External external = value.As<Napi::External<void>>();
                     *(void **)dest = external.Data();
-
-                    dest += type->ref->size;
-                }
+                });
             } break;
             case PrimitiveKind::Record: {
-                for (uint32_t i = 0; i < len; i++) {
-                    Napi::Value value = array[i];
-
-                    int16_t align = std::max(type->ref->align, realign);
-                    dest = AlignUp(dest, align);
-
-                    if (RG_UNLIKELY(!IsObject(value))) {
-                        ThrowError<Napi::TypeError>(env, "Unexpected value %1 in array, expected object", GetValueType(instance, value));
-                        return false;
-                    }
-
+                PUSH_ARRAY(IsObject(value), "object", {
                     Napi::Object obj = value.As<Napi::Object>();
                     if (!PushObject(obj, type->ref, dest, realign))
                         return false;
-
-                    dest += type->ref->size;
-                }
+                });
             } break;
             case PrimitiveKind::Array: {
-                for (uint32_t i = 0; i < len; i++) {
-                    Napi::Value value = array[i];
-
-                    int16_t align = std::max(type->ref->align, realign);
-                    dest = AlignUp(dest, align);
-
-                    if (RG_UNLIKELY(!value.IsArray() && !value.IsTypedArray())) {
-                        ThrowError<Napi::TypeError>(env, "Unexpected value %1 in array, expected array", GetValueType(instance, value));
-                        return false;
-                    }
-
-                    Napi::Array array = value.As<Napi::Array>();
+                PUSH_ARRAY(value.IsArray() || value.IsTypedArray(), "array", {
+                    Napi::Object array = value.As<Napi::Array>();
                     if (!PushArray(array, type->ref, dest, realign))
                         return false;
-
-                    dest += type->ref->size;
-                }
+                });
             } break;
             case PrimitiveKind::Float32: {
-                for (uint32_t i = 0; i < len; i++) {
-                    Napi::Value value = array[i];
-
-                    int16_t align = std::max(type->ref->align, realign);
-                    dest = AlignUp(dest, align);
-
-                    if (RG_UNLIKELY(!value.IsNumber() && !value.IsBigInt())) {
-                        ThrowError<Napi::TypeError>(env, "Unexpected value %1 in array, expected number", GetValueType(instance, value));
-                        return false;
-                    }
-
+                PUSH_ARRAY(value.IsNumber() || value.IsBigInt(), "number", {
                     float f = CopyNumber<float>(value);
                     *(float *)dest = f;
-
-                    dest += type->ref->size;
-                }
+                });
             } break;
             case PrimitiveKind::Float64: {
-                for (uint32_t i = 0; i < len; i++) {
-                    Napi::Value value = array[i];
-
-                    int16_t align = std::max(type->ref->align, realign);
-                    dest = AlignUp(dest, align);
-
-                    if (RG_UNLIKELY(!value.IsNumber() && !value.IsBigInt())) {
-                        ThrowError<Napi::TypeError>(env, "Unexpected value %1 in array, expected number", GetValueType(instance, value));
-                        return false;
-                    }
-
+                PUSH_ARRAY(value.IsNumber() || value.IsBigInt(), "number", {
                     double d = CopyNumber<double>(value);
                     *(double *)dest = d;
-
-                    dest += type->ref->size;
-                }
+                });
             } break;
         }
+
+#undef PUSH_ARRAY
     } else {
         Napi::TypedArray array = obj.As<Napi::TypedArray>();
         const uint8_t *buf = (const uint8_t *)array.ArrayBuffer().Data();
 
-        if (array.ElementLength() != len) {
+        if (RG_UNLIKELY(array.ElementLength() != len)) {
             ThrowError<Napi::Error>(env, "Expected array of length %1, got %2", len, array.ElementLength());
             return false;
         }
@@ -452,7 +365,7 @@ bool CallData::PushArray(const Napi::Object &obj, const TypeInfo *type, uint8_t
 
             default: { match = false; } break;
         }
-        if (!match) {
+        if (RG_UNLIKELY(!match)) {
             ThrowError<Napi::TypeError>(env, "TypedArray is not approriate for %1 array", type->ref->name);
             return false;
         }
@@ -570,255 +483,113 @@ Napi::Object CallData::PopArray(const uint8_t *src, const TypeInfo *type, int16_
 
     uint32_t len = type->size / type->ref->size;
 
+#define POP_ARRAY(SetCode) \
+        do { \
+            Napi::Array array = Napi::Array::New(env); \
+             \
+            for (uint32_t i = 0; i < len; i++) { \
+                int16_t align = std::max(realign, type->ref->align); \
+                src = AlignUp(src, align); \
+                 \
+                SetCode \
+                 \
+                src += type->ref->size; \
+            } \
+             \
+            return array; \
+        } while (false)
+#define POP_NUMBER_ARRAY(TypedArrayType, CType) \
+        do { \
+            if (type->hint == TypeInfo::ArrayHint::TypedArray) { \
+                Napi::TypedArrayType array = Napi::TypedArrayType::New(env, len); \
+                 \
+                for (uint32_t i = 0; i < len; i++) { \
+                    int16_t align = std::max(realign, type->ref->align); \
+                    src = AlignUp(src, align); \
+                     \
+                    CType f = *(CType *)src; \
+                    array[i] = f; \
+                     \
+                    src += type->ref->size; \
+                } \
+                 \
+                return array; \
+            } else { \
+                POP_ARRAY({ \
+                    double d = (double)*(CType *)src; \
+                    array.Set(i, Napi::Number::New(env, d)); \
+                }); \
+            } \
+        } while (false)
+
     switch (type->ref->primitive) {
         case PrimitiveKind::Void: { RG_UNREACHABLE(); } break;
 
         case PrimitiveKind::Bool: {
-            Napi::Array array = Napi::Array::New(env);
-
-            for (uint32_t i = 0; i < len; i++) {
-                int16_t align = std::max(realign, type->ref->align);
-                src = AlignUp(src, align);
-
+            POP_ARRAY({
                 bool b = *(bool *)src;
                 array.Set(i, Napi::Boolean::New(env, b));
-
-                src += type->ref->size;
-            }
-
-            return array;
-        } break;
-        case PrimitiveKind::Int8: {
-            Napi::Int8Array array = Napi::Int8Array::New(env, len);
-
-            for (uint32_t i = 0; i < len; i++) {
-                int16_t align = std::max(realign, type->ref->align);
-                src = AlignUp(src, align);
-
-                int8_t v = *(int8_t *)src;
-                array[i] = v;
-
-                src += type->ref->size;
-            }
-
-            return array;
-        } break;
-        case PrimitiveKind::UInt8: {
-            Napi::Uint8Array array = Napi::Uint8Array::New(env, len);
-
-            for (uint32_t i = 0; i < len; i++) {
-                int16_t align = std::max(realign, type->ref->align);
-                src = AlignUp(src, align);
-
-                uint8_t v = *(uint8_t *)src;
-                array[i] = v;
-
-                src += type->ref->size;
-            }
-
-            return array;
-        } break;
-        case PrimitiveKind::Int16: {
-            Napi::Int16Array array = Napi::Int16Array::New(env, len);
-
-            for (uint32_t i = 0; i < len; i++) {
-                int16_t align = std::max(realign, type->ref->align);
-                src = AlignUp(src, align);
-
-                int16_t v = *(int16_t *)src;
-                array[i] = v;
-
-                src += type->ref->size;
-            }
-
-            return array;
-        } break;
-        case PrimitiveKind::UInt16: {
-            Napi::Uint16Array array = Napi::Uint16Array::New(env, len);
-
-            for (uint32_t i = 0; i < len; i++) {
-                int16_t align = std::max(realign, type->ref->align);
-                src = AlignUp(src, align);
-
-                uint16_t v = *(uint16_t *)src;
-                array[i] = v;
-
-                src += type->ref->size;
-            }
-
-            return array;
-        } break;
-        case PrimitiveKind::Int32: {
-            Napi::Int32Array array = Napi::Int32Array::New(env, len);
-
-            for (uint32_t i = 0; i < len; i++) {
-                int16_t align = std::max(realign, type->ref->align);
-                src = AlignUp(src, align);
-
-                int32_t v = *(int32_t *)src;
-                array[i] = v;
-
-                src += type->ref->size;
-            }
-
-            return array;
-        } break;
-        case PrimitiveKind::UInt32: {
-            Napi::Uint32Array array = Napi::Uint32Array::New(env, len);
-
-            for (uint32_t i = 0; i < len; i++) {
-                int16_t align = std::max(realign, type->ref->align);
-                src = AlignUp(src, align);
-
-                uint32_t v = *(uint32_t *)src;
-                array[i] = v;
-
-                src += type->ref->size;
-            }
-
-            return array;
+            });
         } break;
+        case PrimitiveKind::Int8: { POP_NUMBER_ARRAY(Int8Array, int8_t); } break;
+        case PrimitiveKind::UInt8: { POP_NUMBER_ARRAY(Uint8Array, uint8_t); } break;
+        case PrimitiveKind::Int16: { POP_NUMBER_ARRAY(Int16Array, int16_t); } break;
+        case PrimitiveKind::UInt16: { POP_NUMBER_ARRAY(Uint16Array, uint16_t); } break;
+        case PrimitiveKind::Int32: { POP_NUMBER_ARRAY(Int32Array, int32_t); } break;
+        case PrimitiveKind::UInt32: { POP_NUMBER_ARRAY(Uint32Array, uint32_t); } break;
         case PrimitiveKind::Int64: {
-            Napi::Array array = Napi::Array::New(env);
-
-            for (uint32_t i = 0; i < len; i++) {
-                int16_t align = std::max(realign, type->ref->align);
-                src = AlignUp(src, align);
-
+            POP_ARRAY({
                 int64_t v = *(int64_t *)src;
                 array.Set(i, Napi::BigInt::New(env, v));
-
-                src += type->ref->size;
-            }
-
-            return array;
+            });
         } break;
         case PrimitiveKind::UInt64: {
-            Napi::Array array = Napi::Array::New(env);
-
-            for (uint32_t i = 0; i < len; i++) {
-                int16_t align = std::max(realign, type->ref->align);
-                src = AlignUp(src, align);
-
+            POP_ARRAY({
                 uint64_t v = *(uint64_t *)src;
                 array.Set(i, Napi::BigInt::New(env, v));
-
-                src += type->ref->size;
-            }
-
-            return array;
+            });
         } break;
         case PrimitiveKind::String: {
-            Napi::Array array = Napi::Array::New(env);
-
-            for (uint32_t i = 0; i < len; i++) {
-                int16_t align = std::max(realign, type->ref->align);
-                src = AlignUp(src, align);
-
+            POP_ARRAY({
                 const char *str = *(const char **)src;
                 array.Set(i, Napi::String::New(env, str));
-
-                src += type->ref->size;
-            }
-
-            return array;
+            });
         } break;
         case PrimitiveKind::String16: {
-            Napi::Array array = Napi::Array::New(env);
-
-            for (uint32_t i = 0; i < len; i++) {
-                int16_t align = std::max(realign, type->ref->align);
-                src = AlignUp(src, align);
-
+            POP_ARRAY({
                 const char16_t *str16 = *(const char16_t **)src;
                 array.Set(i, Napi::String::New(env, str16));
-
-                src += type->ref->size;
-            }
-
-            return array;
+            });
         } break;
         case PrimitiveKind::Pointer: {
-            Napi::Array array = Napi::Array::New(env);
-
-            for (uint32_t i = 0; i < len; i++) {
-                int16_t align = std::max(realign, type->ref->align);
-                src = AlignUp(src, align);
-
+            POP_ARRAY({
                 void *ptr2 = *(void **)src;
 
                 Napi::External<void> external = Napi::External<void>::New(env, ptr2);
                 SetValueTag(instance, external, type->ref);
 
                 array.Set(i, external);
-
-                src += type->ref->size;
-            }
-
-            return array;
+            });
         } break;
         case PrimitiveKind::Record: {
-            Napi::Array array = Napi::Array::New(env);
-
-            for (uint32_t i = 0; i < len; i++) {
-                int16_t align = std::max(realign, type->ref->align);
-                src = AlignUp(src, align);
-
+            POP_ARRAY({
                 Napi::Object obj = PopObject(src, type->ref, realign);
                 array.Set(i, obj);
-
-                src += type->ref->size;
-            }
-
-            return array;
+            });
         } break;
         case PrimitiveKind::Array: {
-            Napi::Array array = Napi::Array::New(env);
-
-            for (uint32_t i = 0; i < len; i++) {
-                int16_t align = std::max(realign, type->ref->align);
-                src = AlignUp(src, align);
-
+            POP_ARRAY({
                 Napi::Object obj = PopArray(src, type->ref, realign);
                 array.Set(i, obj);
-
-                src += type->ref->size;
-            }
-
-            return array;
-        } break;
-        case PrimitiveKind::Float32: {
-            Napi::Float32Array array = Napi::Float32Array::New(env, len);
-
-            for (uint32_t i = 0; i < len; i++) {
-                int16_t align = std::max(realign, type->ref->align);
-                src = AlignUp(src, align);
-
-                float f = *(float *)src;
-                array[i] = f;
-
-                src += type->ref->size;
-            }
-
-            return array;
-        } break;
-        case PrimitiveKind::Float64: {
-            Napi::Float64Array array = Napi::Float64Array::New(env, len);
-
-            for (uint32_t i = 0; i < len; i++) {
-                int16_t align = std::max(realign, type->ref->align);
-                src = AlignUp(src, align);
-
-                double d = *(double *)src;
-                array[i] = d;
-
-                src += type->ref->size;
-            }
-
-            return array;
+            });
         } break;
+        case PrimitiveKind::Float32: { POP_NUMBER_ARRAY(Float32Array, float); } break;
+        case PrimitiveKind::Float64: { POP_NUMBER_ARRAY(Float64Array, double); } break;
     }
 
+#undef POP_NUMBER_ARRAY
+#undef POP_ARRAY
+
     RG_UNREACHABLE();
 }
 

package/src/ffi.cc

@@ -261,6 +261,27 @@ static Napi::Value CreateArrayType(const Napi::CallbackInfo &info)
         return env.Null();
     }
 
+    TypeInfo::ArrayHint hint;
+    if (info.Length() >= 3 && !IsNullOrUndefined(info[2])) {
+        if (!info[2].IsString()) {
+            ThrowError<Napi::TypeError>(env, "Unexpected %1 value for hint, expected string", GetValueType(instance, info[2]));
+            return env.Null();
+        }
+
+        std::string to = info[2].As<Napi::String>();
+
+        if (to == "typed") {
+            hint = TypeInfo::ArrayHint::TypedArray;
+        } else if (to == "array") {
+            hint = TypeInfo::ArrayHint::Array;
+        } else {
+            ThrowError<Napi::Error>(env, "Array conversion hint must be 'typed' or 'array'");
+            return env.Null();
+        }
+    } else {
+        hint = TypeInfo::ArrayHint::TypedArray;
+    }
+
     const TypeInfo *ref = ResolveType(instance, info[0]);
     int64_t len = (uint16_t)info[1].As<Napi::Number>().Int64Value();
 
@@ -284,6 +305,7 @@ static Napi::Value CreateArrayType(const Napi::CallbackInfo &info)
     type->align = ref->align;
     type->size = (int16_t)(len * ref->size);
     type->ref = ref;
+    type->hint = hint;
 
     // If the insert succeeds, we cannot fail anymore
     if (!instance->types_map.TrySet(type).second) {
@@ -395,7 +417,7 @@ static Napi::Value TranslateNormalCall(const Napi::CallbackInfo &info)
     InstanceData *instance = env.GetInstanceData<InstanceData>();
     FunctionInfo *func = (FunctionInfo *)info.Data();
 
-    if (info.Length() < (uint32_t)func->parameters.len) {
+    if (RG_UNLIKELY(info.Length() < (uint32_t)func->parameters.len)) {
         ThrowError<Napi::TypeError>(env, "Expected %1 arguments, got %2", func->parameters.len, info.Length());
         return env.Null();
     }
@@ -421,11 +443,11 @@ static Napi::Value TranslateVariadicCall(const Napi::CallbackInfo &info)
         func.parameters.Leak();
     };
 
-    if (info.Length() < (uint32_t)func.parameters.len) {
+    if (RG_UNLIKELY(info.Length() < (uint32_t)func.parameters.len)) {
         ThrowError<Napi::TypeError>(env, "Expected %1 arguments or more, got %2", func.parameters.len, info.Length());
         return env.Null();
     }
-    if ((info.Length() - func.parameters.len) % 2) {
+    if (RG_UNLIKELY((info.Length() - func.parameters.len) % 2)) {
         ThrowError<Napi::Error>(env, "Missing value argument for variadic call");
         return env.Null();
     }
@@ -434,19 +456,19 @@ static Napi::Value TranslateVariadicCall(const Napi::CallbackInfo &info)
         ParameterInfo param = {};
 
         param.type = ResolveType(instance, info[i], &param.directions);
-        if (!param.type)
+        if (RG_UNLIKELY(!param.type))
             return env.Null();
-        if (param.type->primitive == PrimitiveKind::Void ||
-                param.type->primitive == PrimitiveKind::Array) {
+        if (RG_UNLIKELY(param.type->primitive == PrimitiveKind::Void ||
+                        param.type->primitive == PrimitiveKind::Array)) {
             ThrowError<Napi::TypeError>(env, "Type %1 cannot be used as a parameter", PrimitiveKindNames[(int)param.type->primitive]);
             return env.Null();
         }
 
-        if (func.parameters.len >= MaxParameters) {
+        if (RG_UNLIKELY(func.parameters.len >= MaxParameters)) {
             ThrowError<Napi::TypeError>(env, "Functions cannot have more than %1 parameters", MaxParameters);
             return env.Null();
         }
-        if ((param.directions & 2) && ++func.out_parameters >= MaxOutParameters) {
+        if (RG_UNLIKELY((param.directions & 2) && ++func.out_parameters >= MaxOutParameters)) {
             ThrowError<Napi::TypeError>(env, "Functions cannot have more than out %1 parameters", MaxOutParameters);
             return env.Null();
         }
@@ -457,7 +479,7 @@ static Napi::Value TranslateVariadicCall(const Napi::CallbackInfo &info)
         func.parameters.Append(param);
     }
 
-    if (!AnalyseFunction(instance, &func))
+    if (RG_UNLIKELY(!AnalyseFunction(instance, &func)))
         return env.Null();
 
     InstanceMemory *mem = AllocateCallMemory(instance);

package/src/ffi.hh

@@ -67,6 +67,11 @@ struct TypeInfo;
 struct RecordMember;
 
 struct TypeInfo {
+    enum class ArrayHint {
+        Array,
+        TypedArray
+    };
+
     const char *name;
     napi_type_tag tag;
 
@@ -78,6 +83,7 @@ struct TypeInfo {
 
     HeapArray<RecordMember> members; // Record only
     const TypeInfo *ref; // Pointer or array
+    ArrayHint hint; // Array only
 
     RG_HASHTABLE_HANDLER(TypeInfo, name);
 };