1 files changed, 15 insertions, 15 deletions

diff --git a/sqlite.zig b/sqlite.zig
index d39f44b..db6ce0d 100644
--- a/sqlite.zig
+++ b/sqlite.zig
@@ -640,19 +640,19 @@ pub const Db = struct {
             .Fn => |fn_info| fn_info,
             else => @compileError("cannot use func, expecting a function"),
         };
-        if (finalize_fn_info.args.len != 1) @compileError("finalize function must take exactly one argument");
+        if (finalize_fn_info.params.len != 1) @compileError("finalize function must take exactly one argument");
         if (finalize_fn_info.is_generic) @compileError("finalize function can't be generic");
         if (finalize_fn_info.is_var_args) @compileError("finalize function can't be variadic");
 
-        if (step_fn_info.args[0].arg_type.? != finalize_fn_info.args[0].arg_type.?) {
+        if (step_fn_info.params[0].type.? != finalize_fn_info.params[0].type.?) {
             @compileError("both step and finalize functions must have the same first argument and it must be a FunctionContext");
         }
-        if (step_fn_info.args[0].arg_type.? != FunctionContext) {
+        if (step_fn_info.params[0].type.? != FunctionContext) {
             @compileError("both step and finalize functions must have a first argument of type FunctionContext");
         }
 
         // subtract the context argument
-        const real_args_len = step_fn_info.args.len - 1;
+        const real_args_len = step_fn_info.params.len - 1;
 
         //
 
@@ -669,7 +669,7 @@ pub const Db = struct {
                 fn xStep(ctx: ?*c.sqlite3_context, argc: c_int, argv: [*c]?*c.sqlite3_value) callconv(.C) void {
                     debug.assert(argc == real_args_len);
 
-                    const sqlite_args = argv.?[0..real_args_len];
+                    const sqlite_args = argv[0..real_args_len];
 
                     var args: std.meta.ArgsTuple(@TypeOf(step_func)) = undefined;
 
@@ -679,14 +679,14 @@ pub const Db = struct {
                     comptime var i: usize = 0;
                     inline while (i < real_args_len) : (i += 1) {
                         // Remember the firt argument is always the function context
-                        const arg = step_fn_info.args[i + 1];
+                        const arg = step_fn_info.params[i + 1];
                         const arg_ptr = &args[i + 1];
 
-                        const ArgType = arg.arg_type.?;
+                        const ArgType = arg.type.?;
                         helpers.setTypeFromValue(ArgType, arg_ptr, sqlite_args[i].?);
                     }
 
-                    @call(.{}, step_func, args);
+                    @call(.auto, step_func, args);
                 }
             }.xStep,
             struct {
@@ -696,7 +696,7 @@ pub const Db = struct {
                     // Pass the function context
                     args[0] = FunctionContext{ .ctx = ctx };
 
-                    const result = @call(.{}, finalize_func, args);
+                    const result = @call(.auto, finalize_func, args);
 
                     helpers.setResult(ctx, result);
                 }
@@ -738,22 +738,22 @@ pub const Db = struct {
         const result = c.sqlite3_create_function_v2(
             self.db,
             func_name,
-            fn_info.args.len,
+            fn_info.params.len,
             flags,
             null,
             struct {
                 fn xFunc(ctx: ?*c.sqlite3_context, argc: c_int, argv: [*c]?*c.sqlite3_value) callconv(.C) void {
-                    debug.assert(argc == fn_info.args.len);
+                    debug.assert(argc == fn_info.params.len);
 
-                    const sqlite_args = argv.?[0..fn_info.args.len];
+                    const sqlite_args = argv[0..fn_info.params.len];
 
                     var fn_args: ArgTuple = undefined;
-                    inline for (fn_info.args) |arg, i| {
-                        const ArgType = arg.arg_type.?;
+                    inline for (fn_info.params) |arg, i| {
+                        const ArgType = arg.type.?;
                         helpers.setTypeFromValue(ArgType, &fn_args[i], sqlite_args[i].?);
                     }
 
-                    const result = @call(.{}, func, fn_args);
+                    const result = @call(.auto, func, fn_args);
 
                     helpers.setResult(ctx, result);
                 }