update toAnyAlloc to support non-const slices (#102)

* remove const qualifier if required

* verify if struct field is optional when lua field is nil

* create a copy of the string if mutation is necessary

* use dupe and dupeZ

Author: axdank

src/lib.zig

@@ -3214,10 +3214,18 @@ pub const Lua = opaque {
                     const string: [*:0]const u8 = try lua.toString(index);
                     const end = std.mem.indexOfSentinel(u8, 0, string);
 
-                    if (info.sentinel == null) {
-                        return string[0..end];
+                    if (!info.is_const) {
+                        if (!allow_alloc) {
+                            @compileError("toAny cannot allocate memory, try using toAnyAlloc");
+                        }
+
+                        if (info.sentinel != null) {
+                            return try a.?.dupeZ(u8, string[0..end]);
+                        } else {
+                            return try a.?.dupe(u8, string[0..end]);
+                        }
                     } else {
-                        return string[0..end :0];
+                        return if (info.sentinel == null) string[0..end] else string[0..end :0];
                     }
                 } else switch (info.size) {
                     .Slice, .Many => {
@@ -3324,6 +3332,7 @@ pub const Lua = opaque {
         var result: T = undefined;
 
         inline for (@typeInfo(T).Struct.fields) |field| {
+            const field_type_info = comptime @typeInfo(field.type);
             const field_name = comptime field.name ++ "";
             _ = lua.pushStringZ(field_name);
 
@@ -3332,7 +3341,7 @@ pub const Lua = opaque {
             if (lua_field_type == .nil) {
                 if (field.default_value) |default_value| {
                     @field(result, field.name) = @as(*const field.type, @ptrCast(@alignCast(default_value))).*;
-                } else {
+                } else if (field_type_info != .Optional) {
                     return error.LuaTableMissingValue;
                 }
             } else {

src/tests.zig

@@ -2446,6 +2446,46 @@ test "toAny struct" {
     ));
 }
 
+test "toAny mutable string" {
+    var lua = try Lua.init(&testing.allocator);
+    defer lua.deinit();
+
+    //[] u8
+    _ = lua.pushStringZ("hello world");
+    const parsed = try lua.toAnyAlloc([]u8, -1);
+    defer parsed.deinit();
+
+    const my_string = parsed.value;
+
+    try testing.expect(std.mem.eql(u8, my_string, "hello world"));
+}
+
+test "toAny mutable string in struct" {
+    var lua = try Lua.init(&testing.allocator);
+    defer lua.deinit();
+
+    const MyType = struct {
+        name: []u8,
+        sentinel: [:0]u8,
+        bar: bool,
+    };
+    try lua.doString("value = {[\"name\"] = \"hi\", [\"sentinel\"] = \"ss\", [\"bar\"] = false}");
+    const lua_type = try lua.getGlobal("value");
+    try testing.expect(lua_type == .table);
+    const parsed = try lua.toAnyAlloc(MyType, 1);
+    defer parsed.deinit();
+
+    const my_struct = parsed.value;
+
+    var name: [2]u8 = .{ 'h', 'i' };
+    var sentinel: [2:0]u8 = .{ 's', 's' };
+
+    try testing.expectEqualDeep(
+        MyType{ .name = &name, .sentinel = &sentinel, .bar = false },
+        my_struct,
+    );
+}
+
 test "toAny struct recursive" {
     var lua = try Lua.init(&testing.allocator);
     defer lua.deinit();