Require a deinit function when allocator is used by an API

src/reflect.zig

@@ -433,6 +433,15 @@ pub const Func = struct {
         try self.return_type.lookup(structs);
     }
 
+    fn hasAlloc(comptime self: Func) bool {
+        for (self.args) |arg| {
+            if (arg.underT() == std.mem.Allocator) {
+                return true;
+            }
+        }
+        return false;
+    }
+
     fn reflect(
         comptime T: type,
         comptime kind: FuncKind,
@@ -870,6 +879,18 @@ pub const Struct = struct {
         return attrs;
     }
 
+    // Does the T has a well-formed deinit method?
+    fn _checkDeinit(comptime T: type, comptime self_T: type, isErr: bool) !void {
+        if (!isDecl(
+            T,
+            "deinit",
+            fn (_: *self_T, _: std.mem.Allocator) void,
+            isErr,
+        )) {
+            return error.StructAllocWrongDeinit;
+        }
+    }
+
     // Is the T a well-formed exception?
     fn _checkException(comptime T: type, isErr: bool) Error!void {
 
@@ -894,6 +915,13 @@ pub const Struct = struct {
         if (!isDecl(T, "get_message", fn (_: T) []const u8, isErr)) return err;
     }
 
+    // Has the API a deinit method?
+    pub fn hasDenit(comptime self: Struct) bool {
+        std.debug.assert(@inComptime());
+        Struct._checkDeinit(self.T, self.Self(), false) catch false;
+        return true;
+    }
+
     // Is the API an exception?
     pub fn isException(comptime self: Struct) bool {
         std.debug.assert(@inComptime());
@@ -1181,6 +1209,44 @@ pub const Struct = struct {
             }
         }
 
+        // check deinit
+        // only if at least one function has an allocator argument
+        var check_deinit = false;
+        if (has_constructor and constructor.hasAlloc()) {
+            check_deinit = true;
+        }
+        if (!check_deinit) {
+            for (getters) |getter| {
+                if (getter.hasAlloc()) {
+                    check_deinit = true;
+                    break;
+                }
+            }
+        }
+        if (!check_deinit) {
+            for (setters) |setter| {
+                if (setter.hasAlloc()) {
+                    check_deinit = true;
+                    break;
+                }
+            }
+        }
+        if (!check_deinit) {
+            for (methods) |method| {
+                if (method.hasAlloc()) {
+                    check_deinit = true;
+                    break;
+                }
+            }
+        }
+        if (check_deinit) {
+            if (self_T) |self| {
+                try Struct._checkDeinit(T, self, true);
+            } else {
+                try Struct._checkDeinit(T, T, true);
+            }
+        }
+
         // string tag
         var string_tag: bool = false;
         for (getters) |getter| {
@@ -1440,6 +1506,7 @@ const Error = error{
     StructExceptionWrongErrorSet,
     StructExceptionWrongInterface,
     StructExceptionDoesNotExist,
+    StructAllocWrongDeinit,
 
     // func errors
     FuncNoSelf,
@@ -1566,10 +1633,30 @@ const MyException = struct {
     pub fn get_message(_: MyException) []const u8 {
         return "";
     }
+    pub fn deinit(_: *MyException, _: std.mem.Allocator) void {}
 };
 const TestStructExceptionDoesNotExist = struct {
     pub const Exception = MyException;
 };
+const TestStructAllocNoDeinit = struct {
+    name: []const u8,
+    pub fn constructor(alloc: std.mem.Allocator, name: []const u8) TestStructAllocWrongDeinit {
+        const name_alloc = alloc.alloc(u8, name.len);
+        @memcpy(name_alloc, name);
+        return .{ .name = name_alloc };
+    }
+};
+const TestStructAllocWrongDeinit = struct {
+    name: []const u8,
+    pub fn constructor(alloc: std.mem.Allocator, name: []const u8) TestStructAllocWrongDeinit {
+        const name_alloc = alloc.alloc(u8, name.len);
+        @memcpy(name_alloc, name);
+        return .{ .name = name_alloc };
+    }
+    pub fn deinit(_: TestStructAllocWrongDeinit, _: std.mem.Allocator) void {
+        // should be a pointer
+    }
+};
 
 // funcs tests
 const TestFuncNoSelf = struct {
@@ -1700,6 +1787,14 @@ pub fn tests() !void {
         .{TestStructExceptionDoesNotExist},
         error.StructExceptionDoesNotExist,
     );
+    try ensureErr(
+        .{TestStructAllocNoDeinit},
+        error.StructAllocWrongDeinit,
+    );
+    try ensureErr(
+        .{TestStructAllocWrongDeinit},
+        error.StructAllocWrongDeinit,
+    );
 
     // funcs checks
     try ensureErr(

src/tests/proto_test.zig

@@ -82,6 +82,10 @@ const Person = struct {
     pub fn get_symbol_toStringTag(_: Person) []const u8 {
         return "MyPerson";
     }
+
+    pub fn deinit(self: *Person, alloc: std.mem.Allocator) void {
+        alloc.free(self.last_name);
+    }
 };
 
 const User = struct {
@@ -103,6 +107,10 @@ const User = struct {
     pub fn get_role(self: User) u8 {
         return self.role;
     }
+
+    pub fn deinit(self: *User, alloc: std.mem.Allocator) void {
+        self.proto.deinit(alloc);
+    }
 };
 
 const PersonPtr = struct {
@@ -126,6 +134,10 @@ const PersonPtr = struct {
         @memcpy(name_alloc, name);
         self.name = name_alloc;
     }
+
+    pub fn deinit(self: *PersonPtr, alloc: std.mem.Allocator) void {
+        alloc.free(self.name);
+    }
 };
 
 const UserForContainer = struct {
@@ -174,6 +186,10 @@ const UserContainer = struct {
     pub fn _roleVal(self: UserForContainer) u8 {
         return self.role;
     }
+
+    pub fn deinit(self: *UserForContainer, alloc: std.mem.Allocator) void {
+        self.proto.deinit(alloc);
+    }
 };
 
 const PersonProtoCast = struct {
@@ -192,6 +208,10 @@ const PersonProtoCast = struct {
     pub fn get_name(self: PersonProtoCast) []const u8 {
         return self.first_name;
     }
+
+    pub fn deinit(self: *PersonProtoCast, alloc: std.mem.Allocator) void {
+        alloc.free(self.first_name);
+    }
 };
 
 const UserProtoCast = struct {
@@ -202,6 +222,10 @@ const UserProtoCast = struct {
     pub fn constructor(alloc: std.mem.Allocator, first_name: []u8) UserProtoCast {
         return .{ .not_proto = PersonProtoCast.constructor(alloc, first_name) };
     }
+
+    pub fn deinit(self: *UserProtoCast, alloc: std.mem.Allocator) void {
+        self.not_proto.deinit(alloc);
+    }
 };
 
 // generate API, comptime

src/tests/types_complex_test.zig

@@ -23,6 +23,10 @@ const MyList = struct {
     pub fn _symbol_iterator(self: MyList) MyIterable {
         return MyIterable.init(self.items);
     }
+
+    pub fn deinit(self: *MyList, alloc: std.mem.Allocator) void {
+        alloc.free(self.items);
+    }
 };
 
 const MyVariadic = struct {
@@ -49,6 +53,8 @@ const MyVariadic = struct {
     pub fn _empty(_: MyVariadic, _: ?VariadicBool) bool {
         return true;
     }
+
+    pub fn deinit(_: *MyVariadic, _: std.mem.Allocator) void {}
 };
 
 const MyErrorUnion = struct {
@@ -111,6 +117,8 @@ pub const MyException = struct {
             ErrorSet.MyCustomError => errorStrings(0),
         };
     }
+
+    pub fn deinit(_: *MyException, _: std.mem.Allocator) void {}
 };
 
 const MyTypeWithException = struct {

src/tests/types_native_test.zig

@@ -25,6 +25,10 @@ const Brand = struct {
         @memcpy(name_alloc, name);
         self.name = name_alloc;
     }
+
+    pub fn deinit(self: *Brand, alloc: std.mem.Allocator) void {
+        alloc.free(self.name);
+    }
 };
 
 const Car = struct {
@@ -118,6 +122,10 @@ const Car = struct {
     pub fn _getBrandPtr(self: Car) *Brand {
         return self.get_brandPtr();
     }
+
+    pub fn deinit(self: *Car, alloc: std.mem.Allocator) void {
+        alloc.destroy(self.brand_ptr);
+    }
 };
 
 // Native types with nested APIs