koffi 1.3.12 → 2.1.0-beta.1

package/src/ffi.cc

@@ -42,6 +42,7 @@ namespace RG {
 
 // Value does not matter, the tag system uses memory addresses
 const int TypeInfoMarker = 0xDEADBEEF;
+const int CastMarker = 0xDEADBEEF;
 
 static bool ChangeMemorySize(const char *name, Napi::Value value, Size *out_size)
 {
@@ -199,8 +200,6 @@ static Napi::Value CreateStructType(const Napi::CallbackInfo &info, bool pad)
 
     type->name = DuplicateString(name.c_str(), &instance->str_alloc).ptr;
 
-    type->defn.Reset(obj, 1);
-
     type->primitive = PrimitiveKind::Record;
     type->align = 1;
 
@@ -211,20 +210,44 @@ static Napi::Value CreateStructType(const Napi::CallbackInfo &info, bool pad)
 
         std::string key = ((Napi::Value)keys[i]).As<Napi::String>();
         Napi::Value value = obj[key];
+        int16_t align = 0;
 
         member.name = DuplicateString(key.c_str(), &instance->str_alloc).ptr;
-        member.type = ResolveType(instance, value);
+
+        if (value.IsArray()) {
+            Napi::Array array = value.As<Napi::Array>();
+
+            if (array.Length() != 2 || !((Napi::Value)array[0u]).IsNumber()) {
+                ThrowError<Napi::Error>(env, "Member specifier array must contain alignement value and type");
+                return env.Null();
+            }
+
+            int64_t align64 = ((Napi::Value)array[0u]).As<Napi::Number>().Int64Value();
+
+            if (align64 < 1 || align64 > 64) {
+                ThrowError<Napi::Error>(env, "Alignment value must be between 1 and 64");
+                return env.Null();
+            }
+
+            value = array[1u];
+            align = (int16_t)align64;
+        }
+ 
+        member.type = ResolveType(value);
         if (!member.type)
             return env.Null();
-        if (member.type->primitive == PrimitiveKind::Void) {
-            ThrowError<Napi::TypeError>(env, "Type Void cannot be used as a member");
+        if (!CanStoreType(member.type)) {
+            ThrowError<Napi::TypeError>(env, "Type %1 cannot be used as a member (maybe try %1 *)", member.type->name);
             return env.Null();
         }
 
-        member.align = pad ? member.type->align : 1;
+        if (!align) {
+            align = pad ? member.type->align : 1;
+        }
+        member.offset = (int16_t)AlignLen(type->size, align);
 
-        type->size = (int16_t)(AlignLen(type->size, member.align) + member.type->size);
-        type->align = std::max(type->align, member.align);
+        type->size = (int16_t)(member.offset + member.type->size);
+        type->align = std::max(type->align, align);
 
         if (!members.TrySet(member.name).second) {
             ThrowError<Napi::Error>(env, "Duplicate member '%1' in struct '%2'", member.name, type->name);
@@ -242,7 +265,7 @@ static Napi::Value CreateStructType(const Napi::CallbackInfo &info, bool pad)
     type->size = (int16_t)AlignLen(type->size, type->align);
 
     // If the insert succeeds, we cannot fail anymore
-    if (named && !instance->types_map.TrySet(type).second) {
+    if (named && !instance->types_map.TrySet(type->name, type).second) {
         ThrowError<Napi::Error>(env, "Duplicate type name '%1'", type->name);
         return env.Null();
     }
@@ -264,45 +287,31 @@ static Napi::Value CreatePackedStructType(const Napi::CallbackInfo &info)
     return CreateStructType(info, false);
 }
 
-static Napi::Value CreateHandleType(const Napi::CallbackInfo &info)
+static Napi::Value CreateOpaqueType(const Napi::CallbackInfo &info)
 {
     Napi::Env env = info.Env();
     InstanceData *instance = env.GetInstanceData<InstanceData>();
 
-    if (info.Length() < 1) {
-        ThrowError<Napi::TypeError>(env, "Expected 1 argument, got %1", info.Length());
-        return env.Null();
-    }
-    if (!info[0].IsString()) {
+    bool named = (info.Length() >= 1);
+
+    if (named && !info[0].IsString()) {
         ThrowError<Napi::TypeError>(env, "Unexpected %1 value for name, expected string", GetValueType(instance, info[0]));
         return env.Null();
     }
 
+    std::string name = named ? info[0].As<Napi::String>() : std::string("<anonymous>");
+
     TypeInfo *type = instance->types.AppendDefault();
     RG_DEFER_N(err_guard) { instance->types.RemoveLast(1); };
 
-    std::string name = info[0].As<Napi::String>();
-
     type->name = DuplicateString(name.c_str(), &instance->str_alloc).ptr;
 
-    type->primitive = PrimitiveKind::Record;
-    type->align = alignof(void *);
-    type->size = RG_SIZE(void *);
-
-    // Add single handle member
-    {
-        RecordMember member = {};
-
-        member.name = "value";
-        member.type = instance->types_map.FindValue("void *", nullptr);
-        RG_ASSERT(member.type);
-        member.align = type->align;
-
-        type->members.Append(member);
-    }
+    type->primitive = PrimitiveKind::Void;
+    type->size = 0;
+    type->align = 0;
 
     // If the insert succeeds, we cannot fail anymore
-    if (!instance->types_map.TrySet(type).second) {
+    if (named && !instance->types_map.TrySet(type->name, type).second) {
         ThrowError<Napi::Error>(env, "Duplicate type name '%1'", type->name);
         return env.Null();
     }
@@ -320,18 +329,65 @@ static Napi::Value CreatePointerType(const Napi::CallbackInfo &info)
     InstanceData *instance = env.GetInstanceData<InstanceData>();
 
     if (info.Length() < 1) {
-        ThrowError<Napi::TypeError>(env, "Expected 1 argument, got %1", info.Length());
+        ThrowError<Napi::TypeError>(env, "Expected 1 to 3 arguments, got %1", info.Length());
         return env.Null();
     }
 
-    const TypeInfo *ref = ResolveType(instance, info[0]);
-    if (!ref)
+    bool named = (info.Length() >= 2 && !info[1].IsNumber());
+
+    if (named && !info[0].IsString()) {
+        ThrowError<Napi::TypeError>(env, "Unexpected %1 value for name, expected string", GetValueType(instance, info[0]));
         return env.Null();
+    }
+
+    std::string name = named ? info[0].As<Napi::String>() : std::string();
+
+    const TypeInfo *type = ResolveType(info[named]);
+    if (!type)
+        return env.Null();
+    if (type->dispose) {
+        ThrowError<Napi::TypeError>(env, "Cannot create pointer to disposable type '%1'", type->name);
+        return env.Null();
+    }
+
+    int count = 0;
+    if (info.Length() >= 2u + named) {
+        if (!info[1 + named].IsNumber()) {
+            ThrowError<Napi::TypeError>(env, "Unexpected %1 value for count, expected number", GetValueType(instance, info[1 + named]));
+            return env.Null();
+        }
+
+        count = info[1 + named].As<Napi::Number>();
+
+        if (count < 1 || count > 4) {
+            ThrowError<Napi::TypeError>(env, "Value of count must be between 1 and 4");
+            return env.Null();
+        }
+    } else {
+        count = 1;
+    }
 
-    TypeInfo *type = (TypeInfo *)GetPointerType(instance, ref);
+    type = MakePointerType(instance, type, count);
     RG_ASSERT(type);
 
-    Napi::External<TypeInfo> external = Napi::External<TypeInfo>::New(env, type);
+    if (named) {
+        TypeInfo *copy = instance->types.AppendDefault();
+        RG_DEFER_N(err_guard) { instance->types.RemoveLast(1); };
+
+        memcpy((void *)copy, type, RG_SIZE(*type));
+        copy->name = DuplicateString(name.c_str(), &instance->str_alloc).ptr;
+
+        // If the insert succeeds, we cannot fail anymore
+        if (!instance->types_map.TrySet(copy->name, copy).second) {
+            ThrowError<Napi::Error>(env, "Duplicate type name '%1'", copy->name);
+            return env.Null();
+        }
+        err_guard.Disable();
+
+        type = copy;
+    }
+
+    Napi::External<TypeInfo> external = Napi::External<TypeInfo>::New(env, (TypeInfo *)type);
     SetValueTag(instance, external, &TypeInfoMarker);
 
     return external;
@@ -349,7 +405,7 @@ static Napi::Value EncodePointerDirection(const Napi::CallbackInfo &info, int di
         return env.Null();
     }
 
-    const TypeInfo *type = ResolveType(instance, info[0]);
+    const TypeInfo *type = ResolveType(info[0]);
     if (!type)
         return env.Null();
 
@@ -382,6 +438,112 @@ static Napi::Value MarkInOut(const Napi::CallbackInfo &info)
     return EncodePointerDirection(info, 3);
 }
 
+static Napi::Value CreateDisposableType(const Napi::CallbackInfo &info)
+{
+    Napi::Env env = info.Env();
+    InstanceData *instance = env.GetInstanceData<InstanceData>();
+
+    if (info.Length() < 1) {
+        ThrowError<Napi::TypeError>(env, "Expected 1 or 2 arguments, got %1", info.Length());
+        return env.Null();
+    }
+
+    bool named = (info.Length() >= 2 && !info[1].IsFunction());
+
+    if (named && !info[0].IsString()) {
+        ThrowError<Napi::TypeError>(env, "Unexpected %1 value for name, expected string", GetValueType(instance, info[0]));
+        return env.Null();
+    }
+
+    std::string name = named ? info[0].As<Napi::String>() : std::string("<anonymous>");
+
+    const TypeInfo *src = ResolveType(info[named]);
+    if (!src)
+        return env.Null();
+    if (src->primitive != PrimitiveKind::String &&
+            src->primitive != PrimitiveKind::String16 &&
+            src->primitive != PrimitiveKind::Pointer) {
+        ThrowError<Napi::TypeError>(env, "Unexpected %1 type, expected pointer or string type", PrimitiveKindNames[(int)src->primitive]);
+        return env.Null();
+    }
+    if (src->dispose) {
+        ThrowError<Napi::TypeError>(env, "Cannot use disposable type '%1' to create new disposable", src->name);
+        return env.Null();
+    }
+
+    DisposeFunc *dispose;
+    Napi::Function dispose_func;
+    if (info.Length() >= 2u + named && !IsNullOrUndefined(info[1 + named])) {
+        Napi::Function func = info[1 + named].As<Napi::Function>();
+
+        if (!func.IsFunction()) {
+            ThrowError<Napi::TypeError>(env, "Unexpected %1 value for func, expected function", GetValueType(instance, func));
+            return env.Null();
+        }
+
+        dispose = [](Napi::Env env, const TypeInfo *type, const void *ptr) {
+            InstanceData *instance = env.GetInstanceData<InstanceData>();
+            const Napi::FunctionReference &ref = type->dispose_ref;
+
+            Napi::External<void> external = Napi::External<void>::New(env, (void *)ptr);
+            SetValueTag(instance, external, type->ref.marker);
+
+            Napi::Value self = env.Null();
+            napi_value args[] = {
+                external
+            };
+
+            ref.Call(self, RG_LEN(args), args);
+        };
+        dispose_func = func;
+    } else {
+        dispose = [](Napi::Env, const TypeInfo *, const void *ptr) { free((void *)ptr); };
+    }
+
+    TypeInfo *type = instance->types.AppendDefault();
+    RG_DEFER_N(err_guard) { instance->types.RemoveLast(1); };
+
+    memcpy((void *)type, (const void *)src, RG_SIZE(*src));
+    type->name = DuplicateString(name.c_str(), &instance->str_alloc).ptr;
+    type->members.allocator = GetNullAllocator();
+    type->dispose = dispose;
+    type->dispose_ref = Napi::Persistent(dispose_func);
+
+    // If the insert succeeds, we cannot fail anymore
+    if (named && !instance->types_map.TrySet(type->name, type).second) {
+        ThrowError<Napi::Error>(env, "Duplicate type name '%1'", type->name);
+        return env.Null();
+    }
+    err_guard.Disable();
+
+    Napi::External<TypeInfo> external = Napi::External<TypeInfo>::New(env, type);
+    SetValueTag(instance, external, &TypeInfoMarker);
+
+    return external;
+}
+
+static Napi::Value CallFree(const Napi::CallbackInfo &info)
+{
+    Napi::Env env = info.Env();
+    InstanceData *instance = env.GetInstanceData<InstanceData>();
+
+    if (info.Length() < 1) {
+        ThrowError<Napi::TypeError>(env, "Expected 1 or 2 arguments, got %1", info.Length());
+        return env.Null();
+    }
+    if (!info[0].IsExternal() || CheckValueTag(instance, info[0], &TypeInfoMarker)) {
+        ThrowError<Napi::TypeError>(env, "Unexpected %1 value for ptr, expected external", GetValueType(instance, info[0]));
+        return env.Null();
+    }
+
+    Napi::External<void> external = info[0].As<Napi::External<void>>();
+    void *ptr = external.Data();
+
+    free(ptr);
+
+    return env.Undefined();
+}
+
 static Napi::Value CreateArrayType(const Napi::CallbackInfo &info)
 {
     Napi::Env env = info.Env();
@@ -396,7 +558,7 @@ static Napi::Value CreateArrayType(const Napi::CallbackInfo &info)
         return env.Null();
     }
 
-    const TypeInfo *ref = ResolveType(instance, info[0]);
+    const TypeInfo *ref = ResolveType(info[0]);
     int64_t len = (uint16_t)info[1].As<Napi::Number>().Int64Value();
 
     if (!ref)
@@ -448,7 +610,7 @@ static Napi::Value CreateArrayType(const Napi::CallbackInfo &info)
     type->primitive = PrimitiveKind::Array;
     type->align = ref->align;
     type->size = (int16_t)(len * ref->size);
-    type->ref = ref;
+    type->ref.type = ref;
     type->hint = hint;
 
     Napi::External<TypeInfo> external = Napi::External<TypeInfo>::New(env, type);
@@ -476,11 +638,11 @@ static bool ParseClassicFunction(Napi::Env env, Napi::String name, Napi::Value r
 
     func->name = DuplicateString(name.ToString().Utf8Value().c_str(), &instance->str_alloc).ptr;
 
-    func->ret.type = ResolveType(instance, ret);
+    func->ret.type = ResolveType(ret);
     if (!func->ret.type)
         return false;
-    if (func->ret.type->primitive == PrimitiveKind::Array) {
-        ThrowError<Napi::Error>(env, "You are not allowed to directly return fixed-size arrays");
+    if (!CanReturnType(func->ret.type)) {
+        ThrowError<Napi::TypeError>(env, "You are not allowed to directly return %1 values (maybe try %1 *)", func->ret.type->name);
         return false;
     }
 
@@ -503,12 +665,11 @@ static bool ParseClassicFunction(Napi::Env env, Napi::String name, Napi::Value r
     for (uint32_t j = 0; j < parameters_len; j++) {
         ParameterInfo param = {};
 
-        param.type = ResolveType(instance, parameters[j], &param.directions);
+        param.type = ResolveType(parameters[j], &param.directions);
         if (!param.type)
             return false;
-        if (param.type->primitive == PrimitiveKind::Void ||
-                param.type->primitive == PrimitiveKind::Array) {
-            ThrowError<Napi::TypeError>(env, "Type %1 cannot be used as a parameter", param.type->name);
+        if (!CanPassType(param.type)) {
+            ThrowError<Napi::TypeError>(env, "Type %1 cannot be used as a parameter (maybe try %1 *)", param.type->name);
             return false;
         }
 
@@ -573,12 +734,12 @@ static Napi::Value CreateCallbackType(const Napi::CallbackInfo &info)
 
     type->name = func->name;
 
-    type->primitive = PrimitiveKind::Callback;
+    type->primitive = PrimitiveKind::Prototype;
     type->align = alignof(void *);
     type->size = RG_SIZE(void *);
-    type->proto = func;
+    type->ref.proto = func;
 
-    instance->types_map.Set(type);
+    instance->types_map.Set(type->name, type);
 
     Napi::External<TypeInfo> external = Napi::External<TypeInfo>::New(env, type);
     SetValueTag(instance, external, &TypeInfoMarker);
@@ -586,17 +747,50 @@ static Napi::Value CreateCallbackType(const Napi::CallbackInfo &info)
     return external;
 }
 
-static Napi::Value GetTypeSize(const Napi::CallbackInfo &info)
+static Napi::Value CreateTypeAlias(const Napi::CallbackInfo &info)
 {
     Napi::Env env = info.Env();
     InstanceData *instance = env.GetInstanceData<InstanceData>();
 
+    if (info.Length() < 2) {
+        ThrowError<Napi::TypeError>(env, "Expected 2 arguments, got %1", info.Length());
+        return env.Null();
+    }
+    if (!info[0].IsString()) {
+        ThrowError<Napi::TypeError>(env, "Unexpected %1 value for name, expected string", GetValueType(instance, info[0]));
+        return env.Null();
+    }
+
+    std::string name = info[0].As<Napi::String>();
+    const char *alias = DuplicateString(name.c_str(), &instance->str_alloc).ptr;
+
+    const TypeInfo *type = ResolveType(info[1]);
+    if (!type)
+        return env.Null();
+
+    std::pair<const TypeInfo **, bool> ret = instance->types_map.TrySet(alias, type);
+
+    if (!ret.second) {
+        ThrowError<Napi::Error>(env, "Type name '%1' already exists", alias);
+        return env.Null();
+    }
+
+    Napi::External<TypeInfo> external = Napi::External<TypeInfo>::New(env, (TypeInfo *)type);
+    SetValueTag(instance, external, &TypeInfoMarker);
+
+    return external;
+}
+
+static Napi::Value GetTypeSize(const Napi::CallbackInfo &info)
+{
+    Napi::Env env = info.Env();
+
     if (info.Length() < 1) {
         ThrowError<Napi::TypeError>(env, "Expected 1 argument, got %1", info.Length());
         return env.Null();
     }
 
-    const TypeInfo *type = ResolveType(instance, info[0]);
+    const TypeInfo *type = ResolveType(info[0]);
     if (!type)
         return env.Null();
 
@@ -606,20 +800,39 @@ static Napi::Value GetTypeSize(const Napi::CallbackInfo &info)
 static Napi::Value GetTypeAlign(const Napi::CallbackInfo &info)
 {
     Napi::Env env = info.Env();
-    InstanceData *instance = env.GetInstanceData<InstanceData>();
 
     if (info.Length() < 1) {
         ThrowError<Napi::TypeError>(env, "Expected 1 argument, got %1", info.Length());
         return env.Null();
     }
 
-    const TypeInfo *type = ResolveType(instance, info[0]);
+    const TypeInfo *type = ResolveType(info[0]);
     if (!type)
         return env.Null();
 
     return Napi::Number::New(env, type->align);
 }
 
+static Napi::Value GetResolvedType(const Napi::CallbackInfo &info)
+{
+    Napi::Env env = info.Env();
+    InstanceData *instance = env.GetInstanceData<InstanceData>();
+
+    if (info.Length() < 1) {
+        ThrowError<Napi::TypeError>(env, "Expected 1 argument, got %1", info.Length());
+        return env.Null();
+    }
+
+    const TypeInfo *type = ResolveType(info[0]);
+    if (!type)
+        return env.Null();
+
+    Napi::External<TypeInfo> external = Napi::External<TypeInfo>::New(env, (TypeInfo *)type);
+    SetValueTag(instance, external, &TypeInfoMarker);
+
+    return external;
+}
+
 static Napi::Value GetTypeDefinition(const Napi::CallbackInfo &info)
 {
     Napi::Env env = info.Env();
@@ -630,12 +843,62 @@ static Napi::Value GetTypeDefinition(const Napi::CallbackInfo &info)
         return env.Null();
     }
 
-    const TypeInfo *type = ResolveType(instance, info[0]);
+    const TypeInfo *type = ResolveType(info[0]);
     if (!type)
         return env.Null();
+
     if (type->defn.IsEmpty()) {
-        ThrowError<Napi::TypeError>(env, "Definition of type %1 is not available", type->name);
-        return env.Null();
+        Napi::Object defn = Napi::Object::New(env);
+
+        defn.Set("name", Napi::String::New(env, type->name));
+        defn.Set("primitive", PrimitiveKindNames[(int)type->primitive]);
+        defn.Set("size", Napi::Number::New(env, (double)type->size));
+        defn.Set("alignment", Napi::Number::New(env, (double)type->align));
+
+        switch (type->primitive) {
+            case PrimitiveKind::Void:
+            case PrimitiveKind::Bool:
+            case PrimitiveKind::Int8:
+            case PrimitiveKind::UInt8:
+            case PrimitiveKind::Int16:
+            case PrimitiveKind::UInt16:
+            case PrimitiveKind::Int32:
+            case PrimitiveKind::UInt32:
+            case PrimitiveKind::Int64:
+            case PrimitiveKind::UInt64:
+            case PrimitiveKind::String:
+            case PrimitiveKind::String16:
+            case PrimitiveKind::Float32:
+            case PrimitiveKind::Float64:
+            case PrimitiveKind::Prototype:
+            case PrimitiveKind::Callback: {} break;
+
+            case PrimitiveKind::Array: {
+                uint32_t len = type->size / type->ref.type->size;
+                defn.Set("length", Napi::Number::New(env, (double)len));
+            } [[fallthrough]];
+            case PrimitiveKind::Pointer: {
+                Napi::External<TypeInfo> external = Napi::External<TypeInfo>::New(env, (TypeInfo *)type->ref.type);
+                SetValueTag(instance, external, &TypeInfoMarker);
+
+                defn.Set("ref", external);
+            } break;
+            case PrimitiveKind::Record: {
+                Napi::Object members = Napi::Object::New(env);
+
+                for (const RecordMember &member: type->members) {
+                    Napi::External<TypeInfo> external = Napi::External<TypeInfo>::New(env, (TypeInfo *)member.type);
+                    SetValueTag(instance, external, &TypeInfoMarker);
+
+                    members.Set(member.name, external);
+                }
+
+                defn.Set("members", members);
+            } break;
+        }
+
+        defn.Freeze();
+        type->defn.Reset(defn, 1);
     }
 
     return type->defn.Value();
@@ -743,12 +1006,11 @@ static Napi::Value TranslateVariadicCall(const Napi::CallbackInfo &info)
     for (Size i = func.parameters.len; i < (Size)info.Length(); i += 2) {
         ParameterInfo param = {};
 
-        param.type = ResolveType(instance, info[i], &param.directions);
+        param.type = ResolveType(info[i], &param.directions);
         if (RG_UNLIKELY(!param.type))
             return env.Null();
-        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]);
+        if (RG_UNLIKELY(!CanPassType(param.type))) {
+            ThrowError<Napi::TypeError>(env, "Type %1 cannot be used as a parameter (maybe try %1 *)", PrimitiveKindNames[(int)param.type->primitive]);
             return env.Null();
         }
 
@@ -866,7 +1128,7 @@ static Napi::Value TranslateAsyncCall(const Napi::CallbackInfo &info)
     }
     async->Queue();
 
-    return env.Null();
+    return env.Undefined();
 }
 
 static Napi::Value FindLibraryFunction(const Napi::CallbackInfo &info, CallConvention convention)
@@ -923,7 +1185,7 @@ static Napi::Value FindLibraryFunction(const Napi::CallbackInfo &info, CallConve
         uint16_t ordinal = (uint16_t)info[0].As<Napi::Number>().Uint32Value();
 
         func->decorated_name = nullptr;
-        func->func = (void *)GetProcAddress((HMODULE)lib->module, (LPCSTR)ordinal);
+        func->func = (void *)GetProcAddress((HMODULE)lib->module, (LPCSTR)(size_t)ordinal);
     }
 #else
     if (func->decorated_name) {
@@ -1032,6 +1294,89 @@ static Napi::Value LoadSharedLibrary(const Napi::CallbackInfo &info)
     return obj;
 }
 
+static Napi::Value RegisterCallback(const Napi::CallbackInfo &info)
+{
+    Napi::Env env = info.Env();
+    InstanceData *instance = env.GetInstanceData<InstanceData>();
+
+    if (info.Length() < 2) {
+        ThrowError<Napi::TypeError>(env, "Expected 2 arguments, got %1", info.Length());
+        return env.Null();
+    }
+    if (!info[0].IsFunction()) {
+        ThrowError<Napi::TypeError>(env, "Unexpected %1 value for func, expected function", GetValueType(instance, info[0]));
+        return env.Null();
+    }
+
+    Napi::Function func = info[0].As<Napi::Function>();
+
+    const TypeInfo *type = ResolveType(info[1]);
+    if (!type)
+        return env.Null();
+    if (type->primitive != PrimitiveKind::Callback) {
+        ThrowError<Napi::TypeError>(env, "Unexpected %1 type, expected <callback> * type", type->name);
+        return env.Null();
+    }
+
+    int idx = CountTrailingZeros(~instance->registered_trampolines);
+
+    if (RG_UNLIKELY(idx >= MaxTrampolines)) {
+        ThrowError<Napi::Error>(env, "Too many registered callbacks are in use (max = %1)", MaxTrampolines);
+        return env.Null();
+    }
+
+    instance->registered_trampolines |= 1u << idx;
+    idx += MaxTrampolines;
+
+    TrampolineInfo *trampoline = &instance->trampolines[idx];
+
+    trampoline->proto = type->ref.proto;
+    trampoline->func.Reset(func, 1);
+    trampoline->generation = -1;
+
+    void *ptr = GetTrampoline(idx, type->ref.proto);
+
+    Napi::External<void> external = Napi::External<void>::New(env, ptr);
+    SetValueTag(instance, external, type->ref.marker);
+
+    return external;
+}
+
+static Napi::Value UnregisterCallback(const Napi::CallbackInfo &info)
+{
+    Napi::Env env = info.Env();
+    InstanceData *instance = env.GetInstanceData<InstanceData>();
+
+    if (info.Length() < 1) {
+        ThrowError<Napi::TypeError>(env, "Expected 1 argument, got %1", info.Length());
+        return env.Null();
+    }
+    if (!info[0].IsExternal()) {
+        ThrowError<Napi::TypeError>(env, "Unexpected %1 value for id, expected registered callback", GetValueType(instance, info[0]));
+        return env.Null();
+    }
+
+    Napi::External<void> external = info[0].As<Napi::External<void>>();
+    void *ptr = external.Data();
+
+    for (Size i = 0; i < MaxTrampolines; i++) {
+        Size idx = i + MaxTrampolines;
+
+        if (!(instance->registered_trampolines & (1u << i)))
+            continue;
+
+        const TrampolineInfo &trampoline = instance->trampolines[idx];
+
+        if (GetTrampoline(idx, trampoline.proto) == ptr) {
+            instance->registered_trampolines &= ~(1u << i);
+            return env.Undefined();
+        }
+    }
+
+    ThrowError<Napi::Error>(env, "Could not find matching registered callback");
+    return env.Null();
+}
+
 LibraryHolder::~LibraryHolder()
 {
 #ifdef _WIN32
@@ -1058,108 +1403,91 @@ void LibraryHolder::Unref() const
     }
 }
 
-static void RegisterPrimitiveType(InstanceData *instance, const char *name, PrimitiveKind primitive,
-                                  int16_t size, int16_t align)
+static inline PrimitiveKind GetIntegerPrimitive(Size len, bool sign)
 {
+    switch (len) {
+        case 1: return sign ? PrimitiveKind::Int8 : PrimitiveKind::UInt8;
+        case 2: return sign ? PrimitiveKind::Int16 : PrimitiveKind::UInt16;
+        case 4: return sign ? PrimitiveKind::Int32 : PrimitiveKind::UInt32;
+        case 8: return sign ? PrimitiveKind::Int64 : PrimitiveKind::UInt64;
+    }
+
+    RG_UNREACHABLE();
+}
+
+static void RegisterPrimitiveType(Napi::Env env, Napi::Object map, std::initializer_list<const char *> names,
+                                  PrimitiveKind primitive, int16_t size, int16_t align, const char *ref = nullptr)
+{
+    RG_ASSERT(names.size() > 0);
     RG_ASSERT(align <= size);
 
+    InstanceData *instance = env.GetInstanceData<InstanceData>();
+
     TypeInfo *type = instance->types.AppendDefault();
 
-    type->name = name;
+    type->name = *names.begin();
 
     type->primitive = primitive;
     type->size = size;
     type->align = align;
 
-    RG_ASSERT(!instance->types_map.Find(name));
-    instance->types_map.Set(type);
-}
+    if (ref) {
+        const TypeInfo *marker = instance->types_map.FindValue(ref, nullptr);
+        RG_ASSERT(marker);
 
-template <typename T>
-static inline PrimitiveKind GetIntegerPrimitive(bool sign)
-{
-    switch (RG_SIZE(T)) {
-        case 1: return sign ? PrimitiveKind::Int8 : PrimitiveKind::UInt8;
-        case 2: return sign ? PrimitiveKind::Int16 : PrimitiveKind::UInt16;
-        case 4: return sign ? PrimitiveKind::Int32 : PrimitiveKind::UInt32;
-        case 8: return sign ? PrimitiveKind::Int64 : PrimitiveKind::UInt64;
+        type->ref.marker = marker;
     }
 
-    RG_UNREACHABLE();
+    Napi::External<TypeInfo> external = Napi::External<TypeInfo>::New(env, type);
+    SetValueTag(instance, external, &TypeInfoMarker);
+
+    for (const char *name: names) {
+        std::pair<const TypeInfo **, bool> ret = instance->types_map.TrySet(name, type);
+        RG_ASSERT(ret.second);
+
+        if (!EndsWith(name, "*")) {
+            map.Set(name, external);
+        }
+    }
 }
 
 static Napi::Object InitBaseTypes(Napi::Env env)
 {
     InstanceData *instance = env.GetInstanceData<InstanceData>();
 
-    RG_ASSERT(!instance->types.len);
-
-    RegisterPrimitiveType(instance, "void", PrimitiveKind::Void, 0, 0);
-    RegisterPrimitiveType(instance, "void *", PrimitiveKind::Pointer, RG_SIZE(void *), alignof(void *));
-    RegisterPrimitiveType(instance, "bool", PrimitiveKind::Bool, RG_SIZE(bool), alignof(bool));
-    RegisterPrimitiveType(instance, "int8", PrimitiveKind::Int8, 1, 1);
-    RegisterPrimitiveType(instance, "int8_t", PrimitiveKind::Int8, 1, 1);
-    RegisterPrimitiveType(instance, "uint8", PrimitiveKind::UInt8, 1, 1);
-    RegisterPrimitiveType(instance, "uint8_t", PrimitiveKind::UInt8, 1, 1);
-    RegisterPrimitiveType(instance, "char", PrimitiveKind::Int8, 1, 1);
-    RegisterPrimitiveType(instance, "uchar", PrimitiveKind::UInt8, 1, 1);
-    RegisterPrimitiveType(instance, "unsigned char", PrimitiveKind::UInt8, 1, 1);
-    RegisterPrimitiveType(instance, "char16", PrimitiveKind::Int16, 2, 2);
-    RegisterPrimitiveType(instance, "char16_t", PrimitiveKind::Int16, 2, 2);
-    RegisterPrimitiveType(instance, "int16", PrimitiveKind::Int16, 2, 2);
-    RegisterPrimitiveType(instance, "int16_t", PrimitiveKind::Int16, 2, 2);
-    RegisterPrimitiveType(instance, "uint16", PrimitiveKind::UInt16, 2, 2);
-    RegisterPrimitiveType(instance, "uint16_t", PrimitiveKind::UInt16, 2, 2);
-    RegisterPrimitiveType(instance, "short", PrimitiveKind::Int16, 2, 2);
-    RegisterPrimitiveType(instance, "ushort", PrimitiveKind::UInt16, 2, 2);
-    RegisterPrimitiveType(instance, "unsigned short", PrimitiveKind::UInt16, 2, 2);
-    RegisterPrimitiveType(instance, "int32", PrimitiveKind::Int32, 4, 4);
-    RegisterPrimitiveType(instance, "int32_t", PrimitiveKind::Int32, 4, 4);
-    RegisterPrimitiveType(instance, "uint32", PrimitiveKind::UInt32, 4, 4);
-    RegisterPrimitiveType(instance, "uint32_t", PrimitiveKind::UInt32, 4, 4);
-    RegisterPrimitiveType(instance, "int", PrimitiveKind::Int32, 4, 4);
-    RegisterPrimitiveType(instance, "uint", PrimitiveKind::UInt32, 4, 4);
-    RegisterPrimitiveType(instance, "unsigned int", PrimitiveKind::UInt32, 4, 4);
-    RegisterPrimitiveType(instance, "int64", PrimitiveKind::Int64, 8, alignof(int64_t));
-    RegisterPrimitiveType(instance, "int64_t", PrimitiveKind::Int64, 8, alignof(int64_t));
-    RegisterPrimitiveType(instance, "uint64", PrimitiveKind::UInt64, 8, alignof(int64_t));
-    RegisterPrimitiveType(instance, "uint64_t", PrimitiveKind::UInt64, 8, alignof(int64_t));
-    RegisterPrimitiveType(instance, "intptr", GetIntegerPrimitive<intptr_t>(true), RG_SIZE(intptr_t), alignof(intptr_t));
-    RegisterPrimitiveType(instance, "intptr_t", GetIntegerPrimitive<intptr_t>(true), RG_SIZE(intptr_t), alignof(intptr_t));
-    RegisterPrimitiveType(instance, "uintptr", GetIntegerPrimitive<intptr_t>(false), RG_SIZE(intptr_t), alignof(intptr_t));
-    RegisterPrimitiveType(instance, "uintptr_t", GetIntegerPrimitive<intptr_t>(false), RG_SIZE(intptr_t), alignof(intptr_t));
-    RegisterPrimitiveType(instance, "long", GetIntegerPrimitive<long>(true), RG_SIZE(long), alignof(long));
-    RegisterPrimitiveType(instance, "ulong", GetIntegerPrimitive<long>(false), RG_SIZE(long), alignof(long));
-    RegisterPrimitiveType(instance, "unsigned long", GetIntegerPrimitive<long>(false), RG_SIZE(long), alignof(long));
-    RegisterPrimitiveType(instance, "longlong", PrimitiveKind::Int64, RG_SIZE(int64_t), alignof(int64_t));
-    RegisterPrimitiveType(instance, "long long", PrimitiveKind::Int64, RG_SIZE(int64_t), alignof(int64_t));
-    RegisterPrimitiveType(instance, "ulonglong", PrimitiveKind::UInt64, RG_SIZE(uint64_t), alignof(uint64_t));
-    RegisterPrimitiveType(instance, "unsigned long long", PrimitiveKind::UInt64, RG_SIZE(uint64_t), alignof(uint64_t));
-    RegisterPrimitiveType(instance, "float32", PrimitiveKind::Float32, 4, alignof(float));
-    RegisterPrimitiveType(instance, "float64", PrimitiveKind::Float64, 8, alignof(double));
-    RegisterPrimitiveType(instance, "float", PrimitiveKind::Float32, 4, alignof(float));
-    RegisterPrimitiveType(instance, "double", PrimitiveKind::Float64, 8, alignof(double));
-    RegisterPrimitiveType(instance, "string", PrimitiveKind::String, RG_SIZE(void *), alignof(void *));
-    RegisterPrimitiveType(instance, "string16", PrimitiveKind::String16, RG_SIZE(void *), alignof(void *));
-    RegisterPrimitiveType(instance, "str", PrimitiveKind::String, RG_SIZE(void *), alignof(void *));
-    RegisterPrimitiveType(instance, "str16", PrimitiveKind::String16, RG_SIZE(void *), alignof(void *));
-
     Napi::Object types = Napi::Object::New(env);
-    for (TypeInfo &type: instance->types) {
-        Napi::External<TypeInfo> external = Napi::External<TypeInfo>::New(env, &type);
-        SetValueTag(instance, external, &TypeInfoMarker);
 
-        types.Set(type.name, external);
+    RegisterPrimitiveType(env, types, {"void"}, PrimitiveKind::Void, 0, 0);
+    RegisterPrimitiveType(env, types, {"bool"}, PrimitiveKind::Bool, RG_SIZE(bool), alignof(bool));
+    RegisterPrimitiveType(env, types, {"int8_t", "int8"}, PrimitiveKind::Int8, 1, 1);
+    RegisterPrimitiveType(env, types, {"uint8_t", "uint8"}, PrimitiveKind::UInt8, 1, 1);
+    RegisterPrimitiveType(env, types, {"char"}, PrimitiveKind::Int8, 1, 1);
+    RegisterPrimitiveType(env, types, {"unsigned char", "uchar"}, PrimitiveKind::UInt8, 1, 1);
+    RegisterPrimitiveType(env, types, {"char16_t", "char16"}, PrimitiveKind::Int16, 2, 2);
+    RegisterPrimitiveType(env, types, {"int16_t", "int16"}, PrimitiveKind::Int16, 2, 2);
+    RegisterPrimitiveType(env, types, {"uint16_t", "uint16"}, PrimitiveKind::UInt16, 2, 2);
+    RegisterPrimitiveType(env, types, {"short"}, PrimitiveKind::Int16, 2, 2);
+    RegisterPrimitiveType(env, types, {"unsigned short", "ushort"}, PrimitiveKind::UInt16, 2, 2);
+    RegisterPrimitiveType(env, types, {"int32_t", "int32"}, PrimitiveKind::Int32, 4, 4);
+    RegisterPrimitiveType(env, types, {"uint32_t", "uint32"}, PrimitiveKind::UInt32, 4, 4);
+    RegisterPrimitiveType(env, types, {"int"}, PrimitiveKind::Int32, 4, 4);
+    RegisterPrimitiveType(env, types, {"unsigned int", "uint"}, PrimitiveKind::UInt32, 4, 4);
+    RegisterPrimitiveType(env, types, {"int64_t", "int64"}, PrimitiveKind::Int64, 8, alignof(int64_t));
+    RegisterPrimitiveType(env, types, {"uint64_t", "uint64"}, PrimitiveKind::UInt64, 8, alignof(int64_t));
+    RegisterPrimitiveType(env, types, {"intptr_t", "intptr"}, GetIntegerPrimitive(RG_SIZE(intptr_t), true), RG_SIZE(intptr_t), alignof(intptr_t));
+    RegisterPrimitiveType(env, types, {"uintptr_t", "uintptr"}, GetIntegerPrimitive(RG_SIZE(intptr_t), false), RG_SIZE(intptr_t), alignof(intptr_t));
+    RegisterPrimitiveType(env, types, {"long"}, GetIntegerPrimitive(RG_SIZE(long), true), RG_SIZE(long), alignof(long));
+    RegisterPrimitiveType(env, types, {"unsigned long", "ulong"}, GetIntegerPrimitive(RG_SIZE(long), false), RG_SIZE(long), alignof(long));
+    RegisterPrimitiveType(env, types, {"long long", "longlong"}, PrimitiveKind::Int64, RG_SIZE(int64_t), alignof(int64_t));
+    RegisterPrimitiveType(env, types, {"unsigned long long", "ulonglong"}, PrimitiveKind::UInt64, RG_SIZE(uint64_t), alignof(uint64_t));
+    RegisterPrimitiveType(env, types, {"float", "float32"}, PrimitiveKind::Float32, 4, alignof(float));
+    RegisterPrimitiveType(env, types, {"double", "float64"}, PrimitiveKind::Float64, 8, alignof(double));
+    RegisterPrimitiveType(env, types, {"char *", "str", "string"}, PrimitiveKind::String, RG_SIZE(void *), alignof(void *), "char");
+    RegisterPrimitiveType(env, types, {"char16_t *", "char16 *", "str16", "string16"}, PrimitiveKind::String16, RG_SIZE(void *), alignof(void *), "char16_t");
+
+    instance->void_type = instance->types_map.FindValue("void", nullptr);
+    RG_ASSERT(instance->void_type);
 
-        if (strchr(type.name, ' ')) {
-            char name_buf[64] = {};
-            for (Size i = 0; type.name[i]; i++) {
-                RG_ASSERT(i < RG_SIZE(name_buf) - 1);
-                name_buf[i] = type.name[i] != ' ' ? type.name[i] : '_';
-            }
-            types.Set(name_buf, external);
-        }
-    }
     types.Freeze();
 
     return types;
@@ -1211,6 +1539,37 @@ InstanceData::~InstanceData()
     }
 }
 
+static Napi::Value CastValue(const Napi::CallbackInfo &info)
+{
+    Napi::Env env = info.Env();
+    InstanceData *instance = env.GetInstanceData<InstanceData>();
+
+    if (RG_UNLIKELY(info.Length() < 2)) {
+        ThrowError<Napi::TypeError>(env, "Expected 2 arguments, got %1", info.Length());
+        return env.Null();
+    }
+
+    Napi::Value value = info[0];
+
+    const TypeInfo *type = ResolveType(info[1]);
+    if (RG_UNLIKELY(!type))
+        return env.Null();
+    if (type->primitive != PrimitiveKind::Pointer) {
+        ThrowError<Napi::TypeError>(env, "Only pointer types can be used for casting");
+        return env.Null();
+    }
+
+    ValueCast *cast = new ValueCast;
+
+    cast->ref.Reset(value, 1);
+    cast->type = type;
+
+    Napi::External<ValueCast> external = Napi::External<ValueCast>::New(env, cast, [](Napi::Env, ValueCast *cast) { delete cast; });
+    SetValueTag(instance, external, &CastMarker);
+
+    return external;
+}
+
 template <typename Func>
 static void SetExports(Napi::Env env, Func func)
 {
@@ -1218,13 +1577,15 @@ static void SetExports(Napi::Env env, Func func)
 
     func("struct", Napi::Function::New(env, CreatePaddedStructType));
     func("pack", Napi::Function::New(env, CreatePackedStructType));
-    func("handle", Napi::Function::New(env, CreateHandleType));
+    func("opaque", Napi::Function::New(env, CreateOpaqueType));
     func("pointer", Napi::Function::New(env, CreatePointerType));
     func("array", Napi::Function::New(env, CreateArrayType));
     func("callback", Napi::Function::New(env, CreateCallbackType));
+    func("alias", Napi::Function::New(env, CreateTypeAlias));
 
     func("sizeof", Napi::Function::New(env, GetTypeSize));
     func("alignof", Napi::Function::New(env, GetTypeAlign));
+    func("resolve", Napi::Function::New(env, GetResolvedType));
     func("introspect", Napi::Function::New(env, GetTypeDefinition));
 
     func("load", Napi::Function::New(env, LoadSharedLibrary));
@@ -1233,6 +1594,14 @@ static void SetExports(Napi::Env env, Func func)
     func("out", Napi::Function::New(env, MarkOut));
     func("inout", Napi::Function::New(env, MarkInOut));
 
+    func("disposable", Napi::Function::New(env, CreateDisposableType));
+    func("free", Napi::Function::New(env, CallFree));
+
+    func("register", Napi::Function::New(env, RegisterCallback));
+    func("unregister", Napi::Function::New(env, UnregisterCallback));
+
+    func("as", Napi::Function::New(env, CastValue));
+
 #if defined(_WIN32)
     func("extension", Napi::String::New(env, ".dll"));
 #elif defined(__APPLE__)