5 files changed, 182 insertions, 150 deletions

diff --git a/build.zig b/build.zig
index a217191..592055b 100644
--- a/build.zig
+++ b/build.zig
@@ -182,16 +182,19 @@ pub fn build(b: *std.build.Builder) !void {
     const use_bundled = b.option(bool, "use_bundled", "Use the bundled sqlite3 source instead of linking the system library (default false)");
 
     const target = b.standardTargetOptions(.{});
-    const mode = b.standardReleaseOptions();
+    const optimize = b.standardOptimizeOption(.{});
 
     // Tool to preprocess the sqlite header files.
     //
     // Due to limitations of translate-c the standard header files can't be used for building loadable extensions
     // so we have this tool which creates usable header files.
 
-    const preprocess_files_tool = b.addExecutable("preprocess-files", "tools/preprocess_files.zig");
-    preprocess_files_tool.setBuildMode(mode);
-    preprocess_files_tool.setTarget(getTarget(target, true));
+    const preprocess_files_tool = b.addExecutable(.{
+        .name = "preprocess-files",
+        .root_source_file = .{ .path = "tools/preprocess_files.zig" },
+        .target = getTarget(target, true),
+        .optimize = optimize,
+    });
 
     // Add a top-level step to run the preprocess-files tool
     const preprocess_files_run = b.step("preprocess-files", "Run the preprocess-files tool");
@@ -220,32 +223,38 @@ pub fn build(b: *std.build.Builder) !void {
         const bundled = use_bundled orelse test_target.bundled;
         const cross_target = getTarget(test_target.target, bundled);
 
-        const tests = b.addTest("sqlite.zig");
+        const tests = b.addTest(.{
+            .target = cross_target,
+            .root_source_file = .{ .path = "sqlite.zig" },
+        });
 
         if (bundled) {
-            const lib = b.addStaticLibrary("sqlite", null);
+            const lib = b.addStaticLibrary(.{
+                .name = "sqlite",
+                .target = cross_target,
+                .optimize = optimize,
+            });
             lib.addCSourceFile("c/sqlite3.c", &[_][]const u8{"-std=c99"});
             lib.linkLibC();
-            lib.setTarget(cross_target);
-            lib.setBuildMode(mode);
             sqlite3 = lib;
         }
 
-        const lib = b.addStaticLibrary("zig-sqlite", "sqlite.zig");
+        const lib = b.addStaticLibrary(.{
+            .name = "zig-sqlite",
+            .root_source_file = .{ .path = "sqlite.zig" },
+            .target = cross_target,
+            .optimize = optimize,
+        });
         if (bundled) lib.addIncludePath("c");
         linkSqlite(lib);
-        lib.setTarget(cross_target);
-        lib.setBuildMode(mode);
 
         const single_threaded_txt = if (test_target.single_threaded) "single" else "multi";
         tests.setNamePrefix(b.fmt("{s}-{s}-{s} ", .{
             try cross_target.zigTriple(b.allocator),
-            @tagName(mode),
+            @tagName(optimize),
             single_threaded_txt,
         }));
         tests.single_threaded = test_target.single_threaded;
-        tests.setBuildMode(mode);
-        tests.setTarget(cross_target);
         if (bundled) tests.addIncludePath("c");
         linkSqlite(tests);
 
@@ -260,26 +269,33 @@ pub fn build(b: *std.build.Builder) !void {
 
     // Fuzzing
 
-    const lib = b.addStaticLibrary("sqlite", null);
+    const lib = b.addStaticLibrary(.{
+        .name = "sqlite",
+        .target = getTarget(target, true),
+        .optimize = optimize,
+    });
     lib.addCSourceFile("c/sqlite3.c", &[_][]const u8{"-std=c99"});
     lib.addIncludePath("c");
     lib.linkLibC();
-    lib.setBuildMode(mode);
-    lib.setTarget(getTarget(target, true));
 
     // The library
-    const fuzz_lib = b.addStaticLibrary("fuzz-lib", "fuzz/main.zig");
+    const fuzz_lib = b.addStaticLibrary(.{
+        .name = "fuzz-lib",
+        .root_source_file = .{ .path = "fuzz/main.zig" },
+        .target = getTarget(target, true),
+        .optimize = optimize,
+    });
     fuzz_lib.addIncludePath("c");
-    fuzz_lib.setBuildMode(mode);
-    fuzz_lib.setTarget(getTarget(target, true));
     fuzz_lib.linkLibrary(lib);
     fuzz_lib.want_lto = true;
     fuzz_lib.bundle_compiler_rt = true;
-    fuzz_lib.addPackagePath("sqlite", "sqlite.zig");
+    fuzz_lib.addAnonymousModule("sqlite", .{
+        .source_file = .{ .path = "sqlite.zig" },
+    });
 
     // Setup the output name
     const fuzz_executable_name = "fuzz";
-    const fuzz_exe_path = try std.fs.path.join(b.allocator, &.{ b.cache_root, fuzz_executable_name });
+    const fuzz_exe_path = try b.cache_root.join(b.allocator, &.{fuzz_executable_name});
 
     // We want `afl-clang-lto -o path/to/output path/to/library`
     const fuzz_compile = b.addSystemCommand(&.{ "afl-clang-lto", "-o", fuzz_exe_path });
@@ -296,12 +312,17 @@ pub fn build(b: *std.build.Builder) !void {
     fuzz_compile_run.dependOn(&fuzz_install.step);
 
     // Compile a companion exe for debugging crashes
-    const fuzz_debug_exe = b.addExecutable("fuzz-debug", "fuzz/main.zig");
+    const fuzz_debug_exe = b.addExecutable(.{
+        .name = "fuzz-debug",
+        .root_source_file = .{ .path = "fuzz/main.zig" },
+        .target = getTarget(target, true),
+        .optimize = optimize,
+    });
     fuzz_debug_exe.addIncludePath("c");
-    fuzz_debug_exe.setBuildMode(mode);
-    fuzz_debug_exe.setTarget(getTarget(target, true));
     fuzz_debug_exe.linkLibrary(lib);
-    fuzz_debug_exe.addPackagePath("sqlite", "sqlite.zig");
+    fuzz_debug_exe.addAnonymousModule("sqlite", .{
+        .source_file = .{ .path = "sqlite.zig" },
+    });
 
     // Only install fuzz-debug when the fuzz step is run
     const install_fuzz_debug_exe = b.addInstallArtifact(fuzz_debug_exe);
@@ -315,21 +336,32 @@ pub fn build(b: *std.build.Builder) !void {
     //
     // This builds an example shared library with the extension and a binary that tests it.
 
-    const zigcrypto_loadable_ext = b.addSharedLibrary("zigcrypto", "examples/zigcrypto.zig", .unversioned);
+    const zigcrypto_loadable_ext = b.addSharedLibrary(.{
+        .name = "zigcrypto",
+        .root_source_file = .{ .path = "examples/zigcrypto.zig" },
+        .version = null,
+        .target = getTarget(target, true),
+        .optimize = optimize,
+    });
     zigcrypto_loadable_ext.force_pic = true;
     zigcrypto_loadable_ext.addIncludePath("c");
-    zigcrypto_loadable_ext.setBuildMode(mode);
-    zigcrypto_loadable_ext.setTarget(getTarget(target, true));
-    zigcrypto_loadable_ext.addPackagePath("sqlite", "sqlite.zig");
+    zigcrypto_loadable_ext.addAnonymousModule("sqlite", .{
+        .source_file = .{ .path = "sqlite.zig" },
+    });
     zigcrypto_loadable_ext.linkLibrary(lib);
 
     const install_zigcrypto_loadable_ext = b.addInstallArtifact(zigcrypto_loadable_ext);
 
-    const zigcrypto_test = b.addExecutable("zigcrypto-test", "examples/zigcrypto_test.zig");
+    const zigcrypto_test = b.addExecutable(.{
+        .name = "zigcrypto-test",
+        .root_source_file = .{ .path = "examples/zigcrypto_test.zig" },
+        .target = getTarget(target, true),
+        .optimize = optimize,
+    });
     zigcrypto_test.addIncludePath("c");
-    zigcrypto_test.setBuildMode(mode);
-    zigcrypto_test.setTarget(getTarget(target, true));
-    zigcrypto_test.addPackagePath("sqlite", "sqlite.zig");
+    zigcrypto_test.addAnonymousModule("sqlite", .{
+        .source_file = .{ .path = "sqlite.zig" },
+    });
     zigcrypto_test.linkLibrary(lib);
 
     const install_zigcrypto_test = b.addInstallArtifact(zigcrypto_test);
diff --git a/c/loadable_extension.zig b/c/loadable_extension.zig
index 95fd215..0b95806 100644
--- a/c/loadable_extension.zig
+++ b/c/loadable_extension.zig
@@ -25,7 +25,7 @@ pub const sqlite3_str_vappendf = @compileError("sqlite3_str_vappendf can't be im
 pub export fn sqlite3_aggregate_context(p: ?*c.sqlite3_context, nBytes: c_int) callconv(.C) ?*anyopaque {
     return sqlite3_api.*.aggregate_context.?(p, nBytes);
 }
-pub export fn sqlite3_bind_blob(pStmt: ?*c.sqlite3_stmt, i: c_int, zData: ?*const anyopaque, nData: c_int, xDel: ?fn (?*anyopaque) callconv(.C) void) c_int {
+pub export fn sqlite3_bind_blob(pStmt: ?*c.sqlite3_stmt, i: c_int, zData: ?*const anyopaque, nData: c_int, xDel: ?*const fn (?*anyopaque) callconv(.C) void) c_int {
     return sqlite3_api.*.bind_blob.?(pStmt, i, zData, nData, xDel);
 }
 pub export fn sqlite3_bind_double(pStmt: ?*c.sqlite3_stmt, i: c_int, rValue: f64) callconv(.C) c_int {
@@ -49,16 +49,16 @@ pub export fn sqlite3_bind_parameter_index(pStmt: ?*c.sqlite3_stmt, zName: [*c]c
 pub export fn sqlite3_bind_parameter_name(pStmt: ?*c.sqlite3_stmt, i: c_int) [*c]const u8 {
     return sqlite3_api.*.bind_parameter_name.?(pStmt, i);
 }
-pub export fn sqlite3_bind_text(pStmt: ?*c.sqlite3_stmt, i: c_int, zData: [*c]const u8, nData: c_int, xDel: ?fn (?*anyopaque) callconv(.C) void) c_int {
+pub export fn sqlite3_bind_text(pStmt: ?*c.sqlite3_stmt, i: c_int, zData: [*c]const u8, nData: c_int, xDel: ?*const fn (?*anyopaque) callconv(.C) void) c_int {
     return sqlite3_api.*.bind_text.?(pStmt, i, zData, nData, xDel);
 }
-pub export fn sqlite3_bind_text16(pStmt: ?*c.sqlite3_stmt, i: c_int, zData: ?*const anyopaque, nData: c_int, xDel: ?fn (?*anyopaque) callconv(.C) void) c_int {
+pub export fn sqlite3_bind_text16(pStmt: ?*c.sqlite3_stmt, i: c_int, zData: ?*const anyopaque, nData: c_int, xDel: ?*const fn (?*anyopaque) callconv(.C) void) c_int {
     return sqlite3_api.*.bind_text16.?(pStmt, i, zData, nData, xDel);
 }
 pub export fn sqlite3_bind_value(pStmt: ?*c.sqlite3_stmt, i: c_int, pValue: ?*const c.sqlite3_value) c_int {
     return sqlite3_api.*.bind_value.?(pStmt, i, pValue);
 }
-pub export fn sqlite3_busy_handler(db: ?*c.sqlite3, xBusy: ?fn (?*anyopaque, c_int) callconv(.C) c_int, pArg: ?*anyopaque) c_int {
+pub export fn sqlite3_busy_handler(db: ?*c.sqlite3, xBusy: ?*const fn (?*anyopaque, c_int) callconv(.C) c_int, pArg: ?*anyopaque) c_int {
     return sqlite3_api.*.busy_handler.?(db, xBusy, pArg);
 }
 pub export fn sqlite3_busy_timeout(db: ?*c.sqlite3, ms: c_int) c_int {
@@ -70,10 +70,10 @@ pub export fn sqlite3_changes(db: ?*c.sqlite3) c_int {
 pub export fn sqlite3_close(db: ?*c.sqlite3) c_int {
     return sqlite3_api.*.close.?(db);
 }
-pub export fn sqlite3_collation_needed(db: ?*c.sqlite3, pCollNeededArg: ?*anyopaque, xCollNeeded: ?fn (?*anyopaque, ?*c.sqlite3, c_int, [*c]const u8) callconv(.C) void) c_int {
+pub export fn sqlite3_collation_needed(db: ?*c.sqlite3, pCollNeededArg: ?*anyopaque, xCollNeeded: ?*const fn (?*anyopaque, ?*c.sqlite3, c_int, [*c]const u8) callconv(.C) void) c_int {
     return sqlite3_api.*.collation_needed.?(db, pCollNeededArg, xCollNeeded);
 }
-pub export fn sqlite3_collation_needed16(db: ?*c.sqlite3, pCollNeededArg: ?*anyopaque, xCollNeeded16: ?fn (?*anyopaque, ?*c.sqlite3, c_int, ?*const anyopaque) callconv(.C) void) c_int {
+pub export fn sqlite3_collation_needed16(db: ?*c.sqlite3, pCollNeededArg: ?*anyopaque, xCollNeeded16: ?*const fn (?*anyopaque, ?*c.sqlite3, c_int, ?*const anyopaque) callconv(.C) void) c_int {
     return sqlite3_api.*.collation_needed16.?(db, pCollNeededArg, xCollNeeded16);
 }
 pub export fn sqlite3_column_blob(pStmt: ?*c.sqlite3_stmt, iCol: c_int) ?*const anyopaque {
@@ -139,7 +139,7 @@ pub export fn sqlite3_column_type(pStmt: ?*c.sqlite3_stmt, iCol: c_int) c_int {
 pub export fn sqlite3_column_value(pStmt: ?*c.sqlite3_stmt, iCol: c_int) ?*c.sqlite3_value {
     return sqlite3_api.*.column_value.?(pStmt, iCol);
 }
-pub export fn sqlite3_commit_hook(db: ?*c.sqlite3, xCallback: ?fn (?*anyopaque) callconv(.C) c_int, pArg: ?*anyopaque) ?*anyopaque {
+pub export fn sqlite3_commit_hook(db: ?*c.sqlite3, xCallback: ?*const fn (?*anyopaque) callconv(.C) c_int, pArg: ?*anyopaque) ?*anyopaque {
     return sqlite3_api.*.commit_hook.?(db, xCallback, pArg);
 }
 pub export fn sqlite3_complete(sql: [*c]const u8) c_int {
@@ -148,22 +148,22 @@ pub export fn sqlite3_complete(sql: [*c]const u8) c_int {
 pub export fn sqlite3_complete16(sql: ?*const anyopaque) c_int {
     return sqlite3_api.*.complete16.?(sql);
 }
-pub export fn sqlite3_create_collation(db: ?*c.sqlite3, zName: [*c]const u8, eTextRep: c_int, pArg: ?*anyopaque, xCompare: ?fn (?*anyopaque, c_int, ?*const anyopaque, c_int, ?*const anyopaque) callconv(.C) c_int) c_int {
+pub export fn sqlite3_create_collation(db: ?*c.sqlite3, zName: [*c]const u8, eTextRep: c_int, pArg: ?*anyopaque, xCompare: ?*const fn (?*anyopaque, c_int, ?*const anyopaque, c_int, ?*const anyopaque) callconv(.C) c_int) c_int {
     return sqlite3_api.*.create_collation.?(db, zName, eTextRep, pArg, xCompare);
 }
-pub export fn sqlite3_create_collation16(db: ?*c.sqlite3, zName: ?*const anyopaque, eTextRep: c_int, pArg: ?*anyopaque, xCompare: ?fn (?*anyopaque, c_int, ?*const anyopaque, c_int, ?*const anyopaque) callconv(.C) c_int) c_int {
+pub export fn sqlite3_create_collation16(db: ?*c.sqlite3, zName: ?*const anyopaque, eTextRep: c_int, pArg: ?*anyopaque, xCompare: ?*const fn (?*anyopaque, c_int, ?*const anyopaque, c_int, ?*const anyopaque) callconv(.C) c_int) c_int {
     return sqlite3_api.*.create_collation16.?(db, zName, eTextRep, pArg, xCompare);
 }
-pub export fn sqlite3_create_function(db: ?*c.sqlite3, zFunctionName: [*c]const u8, nArg: c_int, eTextRep: c_int, pApp: ?*anyopaque, xFunc: ?fn (?*c.sqlite3_context, c_int, [*c]?*c.sqlite3_value) callconv(.C) void, xStep: ?fn (?*c.sqlite3_context, c_int, [*c]?*c.sqlite3_value) callconv(.C) void, xFinal: ?fn (?*c.sqlite3_context) callconv(.C) void) c_int {
+pub export fn sqlite3_create_function(db: ?*c.sqlite3, zFunctionName: [*c]const u8, nArg: c_int, eTextRep: c_int, pApp: ?*anyopaque, xFunc: ?*const fn (?*c.sqlite3_context, c_int, [*c]?*c.sqlite3_value) callconv(.C) void, xStep: ?*const fn (?*c.sqlite3_context, c_int, [*c]?*c.sqlite3_value) callconv(.C) void, xFinal: ?*const fn (?*c.sqlite3_context) callconv(.C) void) c_int {
     return sqlite3_api.*.create_function.?(db, zFunctionName, nArg, eTextRep, pApp, xFunc, xStep, xFinal);
 }
-pub export fn sqlite3_create_function16(db: ?*c.sqlite3, zFunctionName: ?*const anyopaque, nArg: c_int, eTextRep: c_int, pApp: ?*anyopaque, xFunc: ?fn (?*c.sqlite3_context, c_int, [*c]?*c.sqlite3_value) callconv(.C) void, xStep: ?fn (?*c.sqlite3_context, c_int, [*c]?*c.sqlite3_value) callconv(.C) void, xFinal: ?fn (?*c.sqlite3_context) callconv(.C) void) c_int {
+pub export fn sqlite3_create_function16(db: ?*c.sqlite3, zFunctionName: ?*const anyopaque, nArg: c_int, eTextRep: c_int, pApp: ?*anyopaque, xFunc: ?*const fn (?*c.sqlite3_context, c_int, [*c]?*c.sqlite3_value) callconv(.C) void, xStep: ?*const fn (?*c.sqlite3_context, c_int, [*c]?*c.sqlite3_value) callconv(.C) void, xFinal: ?*const fn (?*c.sqlite3_context) callconv(.C) void) c_int {
     return sqlite3_api.*.create_function16.?(db, zFunctionName, nArg, eTextRep, pApp, xFunc, xStep, xFinal);
 }
 pub export fn sqlite3_create_module(db: ?*c.sqlite3, zName: [*c]const u8, pModule: [*c]const c.sqlite3_module, pAux: ?*anyopaque) c_int {
     return sqlite3_api.*.create_module.?(db, zName, pModule, pAux);
 }
-pub export fn sqlite3_create_module_v2(db: ?*c.sqlite3, zName: [*c]const u8, pModule: [*c]const c.sqlite3_module, pAux: ?*anyopaque, xDestroy: ?fn (?*anyopaque) callconv(.C) void) c_int {
+pub export fn sqlite3_create_module_v2(db: ?*c.sqlite3, zName: [*c]const u8, pModule: [*c]const c.sqlite3_module, pAux: ?*anyopaque, xDestroy: ?*const fn (?*anyopaque) callconv(.C) void) c_int {
     return sqlite3_api.*.create_module_v2.?(db, zName, pModule, pAux, xDestroy);
 }
 pub export fn sqlite3_data_count(pStmt: ?*c.sqlite3_stmt) c_int {
@@ -188,7 +188,7 @@ pub export fn sqlite3_errmsg(db: ?*c.sqlite3) [*c]const u8 {
 pub export fn sqlite3_errmsg16(db: ?*c.sqlite3) ?*const anyopaque {
     return sqlite3_api.*.errmsg16.?(db);
 }
-pub export fn sqlite3_exec(db: ?*c.sqlite3, zSql: [*c]const u8, xCallback: ?fn (?*anyopaque, c_int, [*c][*c]u8, [*c][*c]u8) callconv(.C) c_int, pArg: ?*anyopaque, pzErrMsg: [*c][*c]u8) c_int {
+pub export fn sqlite3_exec(db: ?*c.sqlite3, zSql: [*c]const u8, xCallback: ?*const fn (?*anyopaque, c_int, [*c][*c]u8, [*c][*c]u8) callconv(.C) c_int, pArg: ?*anyopaque, pzErrMsg: [*c][*c]u8) c_int {
     return sqlite3_api.*.exec.?(db, zSql, xCallback, pArg, pzErrMsg);
 }
 pub export fn sqlite3_finalize(pStmt: ?*c.sqlite3_stmt) c_int {
@@ -242,10 +242,10 @@ pub export fn sqlite3_prepare_v2(db: ?*c.sqlite3, zSql: [*c]const u8, nByte: c_i
 pub export fn sqlite3_prepare16_v2(db: ?*c.sqlite3, zSql: ?*const anyopaque, nByte: c_int, ppStmt: [*c]?*c.sqlite3_stmt, pzTail: [*c]?*const anyopaque) c_int {
     return sqlite3_api.*.prepare16_v2.?(db, zSql, nByte, ppStmt, pzTail);
 }
-pub export fn sqlite3_profile(db: ?*c.sqlite3, xProfile: ?fn (?*anyopaque, [*c]const u8, c.sqlite3_uint64) callconv(.C) void, pArg: ?*anyopaque) ?*anyopaque {
+pub export fn sqlite3_profile(db: ?*c.sqlite3, xProfile: ?*const fn (?*anyopaque, [*c]const u8, c.sqlite3_uint64) callconv(.C) void, pArg: ?*anyopaque) ?*anyopaque {
     return sqlite3_api.*.profile.?(db, xProfile, pArg);
 }
-pub export fn sqlite3_progress_handler(db: ?*c.sqlite3, nOps: c_int, xProgress: ?fn (?*anyopaque) callconv(.C) c_int, pArg: ?*anyopaque) void {
+pub export fn sqlite3_progress_handler(db: ?*c.sqlite3, nOps: c_int, xProgress: ?*const fn (?*anyopaque) callconv(.C) c_int, pArg: ?*anyopaque) void {
     return sqlite3_api.*.progress_handler.?(db, nOps, xProgress, pArg);
 }
 pub export fn sqlite3_realloc(pOld: ?*anyopaque, n: c_int) ?*anyopaque {
@@ -254,7 +254,7 @@ pub export fn sqlite3_realloc(pOld: ?*anyopaque, n: c_int) ?*anyopaque {
 pub export fn sqlite3_reset(pStmt: ?*c.sqlite3_stmt) c_int {
     return sqlite3_api.*.reset.?(pStmt);
 }
-pub export fn sqlite3_result_blob(pCtx: ?*c.sqlite3_context, z: ?*const anyopaque, n: c_int, xDel: ?fn (?*anyopaque) callconv(.C) void) void {
+pub export fn sqlite3_result_blob(pCtx: ?*c.sqlite3_context, z: ?*const anyopaque, n: c_int, xDel: ?*const fn (?*anyopaque) callconv(.C) void) void {
     return sqlite3_api.*.result_blob.?(pCtx, z, n, xDel);
 }
 
@@ -277,28 +277,28 @@ pub export fn sqlite3_result_int64(pCtx: ?*c.sqlite3_context, iVal: c.sqlite3_in
 pub export fn sqlite3_result_null(pCtx: ?*c.sqlite3_context) void {
     return sqlite3_api.*.result_null.?(pCtx);
 }
-pub export fn sqlite3_result_text(pCtx: ?*c.sqlite3_context, z: [*c]const u8, n: c_int, xDel: ?fn (?*anyopaque) callconv(.C) void) void {
+pub export fn sqlite3_result_text(pCtx: ?*c.sqlite3_context, z: [*c]const u8, n: c_int, xDel: ?*const fn (?*anyopaque) callconv(.C) void) void {
     return sqlite3_api.*.result_text.?(pCtx, z, n, xDel);
 }
-pub export fn sqlite3_result_text16(pCtx: ?*c.sqlite3_context, z: ?*const anyopaque, n: c_int, xDel: ?fn (?*anyopaque) callconv(.C) void) void {
+pub export fn sqlite3_result_text16(pCtx: ?*c.sqlite3_context, z: ?*const anyopaque, n: c_int, xDel: ?*const fn (?*anyopaque) callconv(.C) void) void {
     return sqlite3_api.*.result_text16.?(pCtx, z, n, xDel);
 }
-pub export fn sqlite3_result_text16be(pCtx: ?*c.sqlite3_context, z: ?*const anyopaque, n: c_int, xDel: ?fn (?*anyopaque) callconv(.C) void) void {
+pub export fn sqlite3_result_text16be(pCtx: ?*c.sqlite3_context, z: ?*const anyopaque, n: c_int, xDel: ?*const fn (?*anyopaque) callconv(.C) void) void {
     return sqlite3_api.*.result_text16be.?(pCtx, z, n, xDel);
 }
-pub export fn sqlite3_result_text16le(pCtx: ?*c.sqlite3_context, z: ?*const anyopaque, n: c_int, xDel: ?fn (?*anyopaque) callconv(.C) void) void {
+pub export fn sqlite3_result_text16le(pCtx: ?*c.sqlite3_context, z: ?*const anyopaque, n: c_int, xDel: ?*const fn (?*anyopaque) callconv(.C) void) void {
     return sqlite3_api.*.result_text16le.?(pCtx, z, n, xDel);
 }
 pub export fn sqlite3_result_value(pCtx: ?*c.sqlite3_context, pValue: ?*c.sqlite3_value) void {
     return sqlite3_api.*.result_value.?(pCtx, pValue);
 }
-pub export fn sqlite3_rollback_hook(db: ?*c.sqlite3, xCallback: ?fn (?*anyopaque) callconv(.C) void, pArg: ?*anyopaque) ?*anyopaque {
+pub export fn sqlite3_rollback_hook(db: ?*c.sqlite3, xCallback: ?*const fn (?*anyopaque) callconv(.C) void, pArg: ?*anyopaque) ?*anyopaque {
     return sqlite3_api.*.rollback_hook.?(db, xCallback, pArg);
 }
-pub export fn sqlite3_set_authorizer(db: ?*c.sqlite3, xAuth: ?fn (?*anyopaque, c_int, [*c]const u8, [*c]const u8, [*c]const u8, [*c]const u8) callconv(.C) c_int, pArg: ?*anyopaque) c_int {
+pub export fn sqlite3_set_authorizer(db: ?*c.sqlite3, xAuth: ?*const fn (?*anyopaque, c_int, [*c]const u8, [*c]const u8, [*c]const u8, [*c]const u8) callconv(.C) c_int, pArg: ?*anyopaque) c_int {
     return sqlite3_api.*.set_authorizer.?(db, xAuth, pArg);
 }
-pub export fn sqlite3_set_auxdata(pCtx: ?*c.sqlite3_context, iArg: c_int, pAux: ?*anyopaque, xDelete: ?fn (?*anyopaque) callconv(.C) void) void {
+pub export fn sqlite3_set_auxdata(pCtx: ?*c.sqlite3_context, iArg: c_int, pAux: ?*anyopaque, xDelete: ?*const fn (?*anyopaque) callconv(.C) void) void {
     return sqlite3_api.*.set_auxdata.?(pCtx, iArg, pAux, xDelete);
 }
 pub export fn sqlite3_step(pStmt: ?*c.sqlite3_stmt) c_int {
@@ -313,10 +313,10 @@ pub export fn sqlite3_thread_cleanup() void {
 pub export fn sqlite3_total_changes(db: ?*c.sqlite3) c_int {
     return sqlite3_api.*.total_changes.?(db);
 }
-pub export fn sqlite3_trace(db: ?*c.sqlite3, xTrace: ?fn (?*anyopaque, [*c]const u8) callconv(.C) void, pArg: ?*anyopaque) ?*anyopaque {
+pub export fn sqlite3_trace(db: ?*c.sqlite3, xTrace: ?*const fn (?*anyopaque, [*c]const u8) callconv(.C) void, pArg: ?*anyopaque) ?*anyopaque {
     return sqlite3_api.*.trace.?(db, xTrace, pArg);
 }
-pub export fn sqlite3_update_hook(db: ?*c.sqlite3, xCallback: ?fn (?*anyopaque, c_int, [*c]const u8, [*c]const u8, c.sqlite3_int64) callconv(.C) void, pArg: ?*anyopaque) ?*anyopaque {
+pub export fn sqlite3_update_hook(db: ?*c.sqlite3, xCallback: ?*const fn (?*anyopaque, c_int, [*c]const u8, [*c]const u8, c.sqlite3_int64) callconv(.C) void, pArg: ?*anyopaque) ?*anyopaque {
     return sqlite3_api.*.update_hook.?(db, xCallback, pArg);
 }
 pub export fn sqlite3_user_data(pCtx: ?*c.sqlite3_context) ?*anyopaque {
@@ -382,7 +382,7 @@ pub export fn sqlite3_blob_read(pBlob: ?*c.sqlite3_blob, z: ?*anyopaque, n: c_in
 pub export fn sqlite3_blob_write(pBlob: ?*c.sqlite3_blob, z: ?*const anyopaque, n: c_int, iOffset: c_int) c_int {
     return sqlite3_api.*.blob_write.?(pBlob, z, n, iOffset);
 }
-pub export fn sqlite3_create_collation_v2(db: ?*c.sqlite3, zName: [*c]const u8, eTextRep: c_int, pCtx: ?*anyopaque, xCompare: ?fn (?*anyopaque, c_int, ?*const anyopaque, c_int, ?*const anyopaque) callconv(.C) c_int, xDel: ?fn (?*anyopaque) callconv(.C) void) c_int {
+pub export fn sqlite3_create_collation_v2(db: ?*c.sqlite3, zName: [*c]const u8, eTextRep: c_int, pCtx: ?*anyopaque, xCompare: ?*const fn (?*anyopaque, c_int, ?*const anyopaque, c_int, ?*const anyopaque) callconv(.C) c_int, xDel: ?*const fn (?*anyopaque) callconv(.C) void) c_int {
     return sqlite3_api.*.create_collation_v2.?(db, zName, eTextRep, pCtx, xCompare, xDel);
 }
 pub export fn sqlite3_file_control(db: ?*c.sqlite3, zDbName: [*c]const u8, op: c_int, pArg: ?*anyopaque) c_int {
@@ -493,10 +493,10 @@ pub export fn sqlite3_create_function_v2(
     nArg: c_int,
     eTextRep: c_int,
     pApp: ?*anyopaque,
-    xFunc: ?fn (?*c.sqlite3_context, c_int, [*c]?*c.sqlite3_value) callconv(.C) void,
-    xStep: ?fn (?*c.sqlite3_context, c_int, [*c]?*c.sqlite3_value) callconv(.C) void,
-    xFinal: ?fn (?*c.sqlite3_context) callconv(.C) void,
-    xDestroy: ?fn (?*anyopaque) callconv(.C) void,
+    xFunc: ?*const fn (?*c.sqlite3_context, c_int, [*c]?*c.sqlite3_value) callconv(.C) void,
+    xStep: ?*const fn (?*c.sqlite3_context, c_int, [*c]?*c.sqlite3_value) callconv(.C) void,
+    xFinal: ?*const fn (?*c.sqlite3_context) callconv(.C) void,
+    xDestroy: ?*const fn (?*anyopaque) callconv(.C) void,
 ) c_int {
     return sqlite3_api.*.create_function_v2.?(db, zFunctionName, nArg, eTextRep, pApp, xFunc, xStep, xFinal, xDestroy);
 }
@@ -521,7 +521,7 @@ pub export fn sqlite3_stmt_status(pStmt: ?*c.sqlite3_stmt, op: c_int, resetFlag:
 pub export fn sqlite3_strnicmp(zLeft: [*c]const u8, zRight: [*c]const u8, N: c_int) c_int {
     return sqlite3_api.*.strnicmp.?(zLeft, zRight, N);
 }
-pub export fn sqlite3_unlock_notify(pBlocked: ?*c.sqlite3, xNotify: ?fn ([*c]?*anyopaque, c_int) callconv(.C) void, pNotifyArg: ?*anyopaque) c_int {
+pub export fn sqlite3_unlock_notify(pBlocked: ?*c.sqlite3, xNotify: ?*const fn ([*c]?*anyopaque, c_int) callconv(.C) void, pNotifyArg: ?*anyopaque) c_int {
     return sqlite3_api.*.unlock_notify.?(pBlocked, xNotify, pNotifyArg);
 }
 pub export fn sqlite3_wal_autocheckpoint(db: ?*c.sqlite3, N: c_int) c_int {
@@ -530,7 +530,7 @@ pub export fn sqlite3_wal_autocheckpoint(db: ?*c.sqlite3, N: c_int) c_int {
 pub export fn sqlite3_wal_checkpoint(db: ?*c.sqlite3, zDb: [*c]const u8) c_int {
     return sqlite3_api.*.wal_checkpoint.?(db, zDb);
 }
-pub export fn sqlite3_wal_hook(db: ?*c.sqlite3, xCallback: ?fn (?*anyopaque, ?*c.sqlite3, [*c]const u8, c_int) callconv(.C) c_int, pArg: ?*anyopaque) ?*anyopaque {
+pub export fn sqlite3_wal_hook(db: ?*c.sqlite3, xCallback: ?*const fn (?*anyopaque, ?*c.sqlite3, [*c]const u8, c_int) callconv(.C) c_int, pArg: ?*anyopaque) ?*anyopaque {
     return sqlite3_api.*.wal_hook.?(db, xCallback, pArg);
 }
 pub export fn sqlite3_blob_reopen(pBlob: ?*c.sqlite3_blob, iRow: c.sqlite3_int64) c_int {
@@ -575,16 +575,16 @@ pub export fn sqlite3_uri_parameter(zFilename: [*c]const u8, zParam: [*c]const u
 pub export fn sqlite3_wal_checkpoint_v2(db: ?*c.sqlite3, zDb: [*c]const u8, eMode: c_int, pnLog: [*c]c_int, pnCkpt: [*c]c_int) c_int {
     return sqlite3_api.*.wal_checkpoint_v2.?(db, zDb, eMode, pnLog, pnCkpt);
 }
-pub export fn sqlite3_auto_extension(xEntryPoint: ?fn () callconv(.C) void) c_int {
+pub export fn sqlite3_auto_extension(xEntryPoint: ?*const fn () callconv(.C) void) c_int {
     return sqlite3_api.*.auto_extension.?(xEntryPoint);
 }
-pub export fn sqlite3_bind_blob64(pStmt: ?*c.sqlite3_stmt, i: c_int, zData: ?*const anyopaque, nData: c.sqlite3_uint64, xDel: ?fn (?*anyopaque) callconv(.C) void) c_int {
+pub export fn sqlite3_bind_blob64(pStmt: ?*c.sqlite3_stmt, i: c_int, zData: ?*const anyopaque, nData: c.sqlite3_uint64, xDel: ?*const fn (?*anyopaque) callconv(.C) void) c_int {
     return sqlite3_api.*.bind_blob64.?(pStmt, i, zData, nData, xDel);
 }
-pub export fn sqlite3_bind_text64(pStmt: ?*c.sqlite3_stmt, i: c_int, zData: [*c]const u8, nData: c.sqlite3_uint64, xDel: ?fn (?*anyopaque) callconv(.C) void, encoding: u8) c_int {
+pub export fn sqlite3_bind_text64(pStmt: ?*c.sqlite3_stmt, i: c_int, zData: [*c]const u8, nData: c.sqlite3_uint64, xDel: ?*const fn (?*anyopaque) callconv(.C) void, encoding: u8) c_int {
     return sqlite3_api.*.bind_text64.?(pStmt, i, zData, nData, xDel, encoding);
 }
-pub export fn sqlite3_cancel_auto_extension(xEntryPoint: ?fn () callconv(.C) void) c_int {
+pub export fn sqlite3_cancel_auto_extension(xEntryPoint: ?*const fn () callconv(.C) void) c_int {
     return sqlite3_api.*.cancel_auto_extension.?(xEntryPoint);
 }
 pub export fn sqlite3_load_extension(db: ?*c.sqlite3, zFile: [*c]const u8, zProc: [*c]const u8, pzErrMsg: [*c][*c]u8) c_int {
@@ -602,10 +602,10 @@ pub export fn sqlite3_realloc64(pOld: ?*anyopaque, n: c.sqlite3_uint64) ?*anyopa
 pub export fn sqlite3_reset_auto_extension() void {
     return sqlite3_api.*.reset_auto_extension.?();
 }
-pub export fn sqlite3_result_blob64(pCtx: ?*c.sqlite3_context, z: ?*const anyopaque, n: c.sqlite3_uint64, xDel: ?fn (?*anyopaque) callconv(.C) void) void {
+pub export fn sqlite3_result_blob64(pCtx: ?*c.sqlite3_context, z: ?*const anyopaque, n: c.sqlite3_uint64, xDel: ?*const fn (?*anyopaque) callconv(.C) void) void {
     return sqlite3_api.*.result_blob64.?(pCtx, z, n, xDel);
 }
-pub export fn sqlite3_result_text64(pCtx: ?*c.sqlite3_context, z: [*c]const u8, n: c.sqlite3_uint64, xDel: ?fn (?*anyopaque) callconv(.C) void, encoding: u8) void {
+pub export fn sqlite3_result_text64(pCtx: ?*c.sqlite3_context, z: [*c]const u8, n: c.sqlite3_uint64, xDel: ?*const fn (?*anyopaque) callconv(.C) void, encoding: u8) void {
     return sqlite3_api.*.result_text64.?(pCtx, z, n, xDel, encoding);
 }
 pub export fn sqlite3_strglob(zGlob: [*c]const u8, zStr: [*c]const u8) c_int {
@@ -641,7 +641,7 @@ pub export fn sqlite3_db_cacheflush(db: ?*c.sqlite3) c_int {
 pub export fn sqlite3_system_errno(db: ?*c.sqlite3) c_int {
     return sqlite3_api.*.system_errno.?(db);
 }
-pub export fn sqlite3_trace_v2(db: ?*c.sqlite3, uMask: c_uint, xCallback: ?fn (c_uint, ?*anyopaque, ?*anyopaque, ?*anyopaque) callconv(.C) c_int, pCtx: ?*anyopaque) c_int {
+pub export fn sqlite3_trace_v2(db: ?*c.sqlite3, uMask: c_uint, xCallback: ?*const fn (c_uint, ?*anyopaque, ?*anyopaque, ?*anyopaque) callconv(.C) c_int, pCtx: ?*anyopaque) c_int {
     return sqlite3_api.*.trace_v2.?(db, uMask, xCallback, pCtx);
 }
 pub export fn sqlite3_expanded_sql(pStmt: ?*c.sqlite3_stmt) [*c]u8 {
@@ -656,10 +656,10 @@ pub export fn sqlite3_prepare_v3(db: ?*c.sqlite3, zSql: [*c]const u8, nByte: c_i
 pub export fn sqlite3_prepare16_v3(db: ?*c.sqlite3, zSql: ?*const anyopaque, nByte: c_int, prepFlags: c_uint, ppStmt: [*c]?*c.sqlite3_stmt, pzTail: [*c]?*const anyopaque) c_int {
     return sqlite3_api.*.prepare16_v3.?(db, zSql, nByte, prepFlags, ppStmt, pzTail);
 }
-pub export fn sqlite3_bind_pointer(pStmt: ?*c.sqlite3_stmt, i: c_int, pPtr: ?*anyopaque, zPTtype: [*c]const u8, xDestructor: ?fn (?*anyopaque) callconv(.C) void) c_int {
+pub export fn sqlite3_bind_pointer(pStmt: ?*c.sqlite3_stmt, i: c_int, pPtr: ?*anyopaque, zPTtype: [*c]const u8, xDestructor: ?*const fn (?*anyopaque) callconv(.C) void) c_int {
     return sqlite3_api.*.bind_pointer.?(pStmt, i, pPtr, zPTtype, xDestructor);
 }
-pub export fn sqlite3_result_pointer(pCtx: ?*c.sqlite3_context, pPtr: ?*anyopaque, zPType: [*c]const u8, xDestructor: ?fn (?*anyopaque) callconv(.C) void) void {
+pub export fn sqlite3_result_pointer(pCtx: ?*c.sqlite3_context, pPtr: ?*anyopaque, zPType: [*c]const u8, xDestructor: ?*const fn (?*anyopaque) callconv(.C) void) void {
     return sqlite3_api.*.result_pointer.?(pCtx, pPtr, zPType, xDestructor);
 }
 pub export fn sqlite3_value_pointer(pVal: ?*c.sqlite3_value, zPType: [*c]const u8) ?*anyopaque {
@@ -716,11 +716,11 @@ pub export fn sqlite3_create_window_function(
     nArg: c_int,
     eTextRep: c_int,
     pArg: ?*anyopaque,
-    xStep: ?fn (?*c.sqlite3_context, c_int, [*c]?*c.sqlite3_value) callconv(.C) void,
-    xFinal: ?fn (?*c.sqlite3_context) callconv(.C) void,
-    xValue: ?fn (?*c.sqlite3_context) callconv(.C) void,
-    xInverse: ?fn (?*c.sqlite3_context, c_int, [*c]?*c.sqlite3_value) callconv(.C) void,
-    xDestroy: ?fn (?*anyopaque) callconv(.C) void,
+    xStep: ?*const fn (?*c.sqlite3_context, c_int, [*c]?*c.sqlite3_value) callconv(.C) void,
+    xFinal: ?*const fn (?*c.sqlite3_context) callconv(.C) void,
+    xValue: ?*const fn (?*c.sqlite3_context) callconv(.C) void,
+    xInverse: ?*const fn (?*c.sqlite3_context, c_int, [*c]?*c.sqlite3_value) callconv(.C) void,
+    xDestroy: ?*const fn (?*anyopaque) callconv(.C) void,
 ) c_int {
     return sqlite3_api.*.create_window_function.?(
         db,
@@ -777,7 +777,7 @@ pub export fn sqlite3_changes64(db: ?*c.sqlite3) c.sqlite3_int64 {
 pub export fn sqlite3_total_changes64(db: ?*c.sqlite3) c.sqlite3_int64 {
     return sqlite3_api.*.total_changes64.?(db);
 }
-pub export fn sqlite3_autovacuum_pages(db: ?*c.sqlite3, xCallback: ?fn (?*anyopaque, [*c]const u8, c_uint, c_uint, c_uint) callconv(.C) c_uint, pArg: ?*anyopaque, xDestructor: ?fn (?*anyopaque) callconv(.C) void) c_int {
+pub export fn sqlite3_autovacuum_pages(db: ?*c.sqlite3, xCallback: ?*const fn (?*anyopaque, [*c]const u8, c_uint, c_uint, c_uint) callconv(.C) c_uint, pArg: ?*anyopaque, xDestructor: ?*const fn (?*anyopaque) callconv(.C) void) c_int {
     return sqlite3_api.*.autovacuum_pages.?(db, xCallback, pArg, xDestructor);
 }
 pub export fn sqlite3_error_offset(db: ?*c.sqlite3) c_int {
diff --git a/helpers.zig b/helpers.zig
index aa04f54..7bcbabe 100644
--- a/helpers.zig
+++ b/helpers.zig
@@ -84,5 +84,5 @@ fn sliceFromValue(sqlite_value: *c.sqlite3_value) []const u8 {
     const value = c.sqlite3_value_text(sqlite_value);
     debug.assert(value != null); // TODO(vincent): how do we handle this properly ?
 
-    return value.?[0..size];
+    return value[0..size];
 }
diff --git a/sqlite.zig b/sqlite.zig
index d39f44b..77c30fc 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, 0..) |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);
                 }
@@ -1395,7 +1395,7 @@ pub fn Iterator(comptime Type: type) type {
 
             var value: Type = undefined;
 
-            inline for (@typeInfo(Type).Struct.fields) |field, _i| {
+            inline for (@typeInfo(Type).Struct.fields, 0..) |field, _i| {
                 const i = @as(usize, _i);
 
                 const ret = try self.readField(field.type, options, i);
@@ -1721,7 +1721,7 @@ pub const DynamicStatement = struct {
 
         switch (@typeInfo(Type)) {
             .Struct => |StructTypeInfo| {
-                inline for (StructTypeInfo.fields) |struct_field, struct_field_i| {
+                inline for (StructTypeInfo.fields, 0..) |struct_field, struct_field_i| {
                     const field_value = @field(values, struct_field.name);
 
                     const i = sqlite3BindParameterIndex(self.stmt, struct_field.name);
@@ -1735,7 +1735,7 @@ pub const DynamicStatement = struct {
             .Pointer => |PointerTypeInfo| {
                 switch (PointerTypeInfo.size) {
                     .Slice => {
-                        for (values) |value_to_bind, index| {
+                        for (values, 0..) |value_to_bind, index| {
                             try self.bindField(PointerTypeInfo.child, options, "unknown", @intCast(c_int, index), value_to_bind);
                         }
                     },
@@ -1743,7 +1743,7 @@ pub const DynamicStatement = struct {
                 }
             },
             .Array => |ArrayTypeInfo| {
-                for (values) |value_to_bind, index| {
+                for (values, 0..) |value_to_bind, index| {
                     try self.bindField(ArrayTypeInfo.child, options, "unknown", @intCast(c_int, index), value_to_bind);
                 }
             },
@@ -2025,7 +2025,7 @@ pub fn Statement(comptime opts: StatementOptions, comptime query: anytype) type
                 }));
             }
 
-            inline for (StructTypeInfo.fields) |struct_field, _i| {
+            inline for (StructTypeInfo.fields, 0..) |struct_field, _i| {
                 const bind_marker = query.bind_markers[_i];
                 if (bind_marker.typed) |typ| {
                     const FieldTypeInfo = @typeInfo(struct_field.type);
@@ -2497,7 +2497,7 @@ test "sqlite: read all users into a struct" {
 
     var rows = try stmt.all(TestUser, allocator, .{}, .{});
     try testing.expectEqual(@as(usize, 3), rows.len);
-    for (rows) |row, i| {
+    for (rows, 0..) |row, i| {
         const exp = test_users[i];
         try testing.expectEqual(exp.id, row.id);
         try testing.expectEqualStrings(exp.name, row.name);
@@ -2623,7 +2623,7 @@ test "sqlite: read a single text value" {
                         const res = mem.sliceTo(&name.?, sentinel);
                         try testing.expectEqualStrings("Vincent", res);
                     } else {
-                        const res = mem.span(&name.?);
+                        const res: []const u8 = &name.?;
                         try testing.expectEqualStrings("Vincent", res);
                     },
                     else => @compileError("invalid type " ++ @typeName(typ)),
@@ -2828,7 +2828,7 @@ test "sqlite: bind pointer" {
     var stmt = try db.prepare(query);
     defer stmt.deinit();
 
-    for (test_users) |test_user, i| {
+    for (test_users, 0..) |test_user, i| {
         stmt.reset();
 
         const name = try stmt.oneAlloc([]const u8, allocator, .{}, .{&test_user.id});
@@ -2864,7 +2864,7 @@ test "sqlite: read pointers" {
     );
 
     try testing.expectEqual(@as(usize, 3), rows.len);
-    for (rows) |row, i| {
+    for (rows, 0..) |row, i| {
         const exp = test_users[i];
         try testing.expectEqual(exp.id, row.id.*);
         try testing.expectEqualStrings(exp.name, row.name.*);
@@ -2998,7 +2998,7 @@ test "sqlite: statement iterator" {
         // Check the data
         try testing.expectEqual(expected_rows.items.len, rows.items.len);
 
-        for (rows.items) |row, j| {
+        for (rows.items, 0..) |row, j| {
             const exp_row = expected_rows.items[j];
             try testing.expectEqualStrings(exp_row.name, mem.sliceTo(&row.name, 0));
             try testing.expectEqual(exp_row.age, row.age);
@@ -3025,7 +3025,7 @@ test "sqlite: statement iterator" {
         // Check the data
         try testing.expectEqual(expected_rows.items.len, rows.items.len);
 
-        for (rows.items) |row, j| {
+        for (rows.items, 0..) |row, j| {
             const exp_row = expected_rows.items[j];
             try testing.expectEqualStrings(exp_row.name, row.name.data);
             try testing.expectEqual(exp_row.age, row.age);
@@ -3386,7 +3386,7 @@ test "sqlite: bind custom type" {
         const rows = try stmt.all(Article, arena.allocator(), .{}, .{});
         try testing.expectEqual(@as(usize, 20), rows.len);
 
-        for (rows) |row, i| {
+        for (rows, 0..) |row, i| {
             var exp_data: MyData = undefined;
             mem.set(u8, &exp_data.data, @intCast(u8, i));
 
diff --git a/vtab.zig b/vtab.zig
index 2c3e329..a7645c3 100644
--- a/vtab.zig
+++ b/vtab.zig
@@ -207,7 +207,7 @@ pub const BestIndexBuilder = struct {
             .id = .{},
         };
 
-        for (res.constraints) |*constraint, i| {
+        for (res.constraints, 0..) |*constraint, i| {
             const raw_constraint = index_info.aConstraint[i];
 
             constraint.column = @intCast(isize, raw_constraint.iColumn);
@@ -233,7 +233,7 @@ pub const BestIndexBuilder = struct {
 
         // Populate the constraint usage
         var constraint_usage: []c.sqlite3_index_constraint_usage = index_info.aConstraintUsage[0..self.constraints.len];
-        for (self.constraints) |constraint, i| {
+        for (self.constraints, 0..) |constraint, i| {
             constraint_usage[i].argvIndex = constraint.usage.argv_index;
             constraint_usage[i].omit = if (constraint.usage.omit) 1 else 0;
         }
@@ -315,9 +315,9 @@ fn validateCursorType(comptime Table: type) void {
 
         const info = @typeInfo(@TypeOf(Cursor.init)).Fn;
 
-        if (info.args.len != 2) @compileError(error_message);
-        if (info.args[0].arg_type.? != mem.Allocator) @compileError(error_message);
-        if (info.args[1].arg_type.? != *Table) @compileError(error_message);
+        if (info.params.len != 2) @compileError(error_message);
+        if (info.params[0].type.? != mem.Allocator) @compileError(error_message);
+        if (info.params[1].type.? != *Table) @compileError(error_message);
         if (info.return_type.? != Cursor.InitError!*Cursor) @compileError(error_message);
     }
 
@@ -333,8 +333,8 @@ fn validateCursorType(comptime Table: type) void {
 
         const info = @typeInfo(@TypeOf(Cursor.deinit)).Fn;
 
-        if (info.args.len != 1) @compileError(error_message);
-        if (info.args[0].arg_type.? != *Cursor) @compileError(error_message);
+        if (info.params.len != 1) @compileError(error_message);
+        if (info.params[0].type.? != *Cursor) @compileError(error_message);
         if (info.return_type.? != void) @compileError(error_message);
     }
 
@@ -354,9 +354,9 @@ fn validateCursorType(comptime Table: type) void {
 
         const info = @typeInfo(@TypeOf(Cursor.next)).Fn;
 
-        if (info.args.len != 2) @compileError(error_message);
-        if (info.args[0].arg_type.? != *Cursor) @compileError(error_message);
-        if (info.args[1].arg_type.? != *VTabDiagnostics) @compileError(error_message);
+        if (info.params.len != 2) @compileError(error_message);
+        if (info.params[0].type.? != *Cursor) @compileError(error_message);
+        if (info.params[1].type.? != *VTabDiagnostics) @compileError(error_message);
         if (info.return_type.? != Cursor.NextError!void) @compileError(error_message);
     }
 
@@ -376,9 +376,9 @@ fn validateCursorType(comptime Table: type) void {
 
         const info = @typeInfo(@TypeOf(Cursor.hasNext)).Fn;
 
-        if (info.args.len != 2) @compileError(error_message);
-        if (info.args[0].arg_type.? != *Cursor) @compileError(error_message);
-        if (info.args[1].arg_type.? != *VTabDiagnostics) @compileError(error_message);
+        if (info.params.len != 2) @compileError(error_message);
+        if (info.params[0].type.? != *Cursor) @compileError(error_message);
+        if (info.params[1].type.? != *VTabDiagnostics) @compileError(error_message);
         if (info.return_type.? != Cursor.HasNextError!bool) @compileError(error_message);
     }
 
@@ -398,11 +398,11 @@ fn validateCursorType(comptime Table: type) void {
 
         const info = @typeInfo(@TypeOf(Cursor.filter)).Fn;
 
-        if (info.args.len != 4) @compileError(error_message);
-        if (info.args[0].arg_type.? != *Cursor) @compileError(error_message);
-        if (info.args[1].arg_type.? != *VTabDiagnostics) @compileError(error_message);
-        if (info.args[2].arg_type.? != IndexIdentifier) @compileError(error_message);
-        if (info.args[3].arg_type.? != []FilterArg) @compileError(error_message);
+        if (info.params.len != 4) @compileError(error_message);
+        if (info.params[0].type.? != *Cursor) @compileError(error_message);
+        if (info.params[1].type.? != *VTabDiagnostics) @compileError(error_message);
+        if (info.params[2].type.? != IndexIdentifier) @compileError(error_message);
+        if (info.params[3].type.? != []FilterArg) @compileError(error_message);
         if (info.return_type.? != Cursor.FilterError!void) @compileError(error_message);
     }
 
@@ -425,10 +425,10 @@ fn validateCursorType(comptime Table: type) void {
 
         const info = @typeInfo(@TypeOf(Cursor.column)).Fn;
 
-        if (info.args.len != 3) @compileError(error_message);
-        if (info.args[0].arg_type.? != *Cursor) @compileError(error_message);
-        if (info.args[1].arg_type.? != *VTabDiagnostics) @compileError(error_message);
-        if (info.args[2].arg_type.? != i32) @compileError(error_message);
+        if (info.params.len != 3) @compileError(error_message);
+        if (info.params[0].type.? != *Cursor) @compileError(error_message);
+        if (info.params[1].type.? != *VTabDiagnostics) @compileError(error_message);
+        if (info.params[2].type.? != i32) @compileError(error_message);
         if (info.return_type.? != Cursor.ColumnError!Cursor.Column) @compileError(error_message);
     }
 
@@ -448,9 +448,9 @@ fn validateCursorType(comptime Table: type) void {
 
         const info = @typeInfo(@TypeOf(Cursor.rowId)).Fn;
 
-        if (info.args.len != 2) @compileError(error_message);
-        if (info.args[0].arg_type.? != *Cursor) @compileError(error_message);
-        if (info.args[1].arg_type.? != *VTabDiagnostics) @compileError(error_message);
+        if (info.params.len != 2) @compileError(error_message);
+        if (info.params[0].type.? != *Cursor) @compileError(error_message);
+        if (info.params[1].type.? != *VTabDiagnostics) @compileError(error_message);
         if (info.return_type.? != Cursor.RowIDError!i64) @compileError(error_message);
     }
 }
@@ -473,11 +473,11 @@ fn validateTableType(comptime Table: type) void {
 
         const info = @typeInfo(@TypeOf(Table.init)).Fn;
 
-        if (info.args.len != 3) @compileError(error_message);
-        if (info.args[0].arg_type.? != mem.Allocator) @compileError(error_message);
-        if (info.args[1].arg_type.? != *VTabDiagnostics) @compileError(error_message);
-        // TODO(vincent): maybe allow a signature without the args since a table can do withoout them
-        if (info.args[2].arg_type.? != []const ModuleArgument) @compileError(error_message);
+        if (info.params.len != 3) @compileError(error_message);
+        if (info.params[0].type.? != mem.Allocator) @compileError(error_message);
+        if (info.params[1].type.? != *VTabDiagnostics) @compileError(error_message);
+        // TODO(vincent): maybe allow a signature without the params since a table can do withoout them
+        if (info.params[2].type.? != []const ModuleArgument) @compileError(error_message);
         if (info.return_type.? != Table.InitError!*Table) @compileError(error_message);
     }
 
@@ -493,9 +493,9 @@ fn validateTableType(comptime Table: type) void {
 
         const info = @typeInfo(@TypeOf(Table.deinit)).Fn;
 
-        if (info.args.len != 2) @compileError(error_message);
-        if (info.args[0].arg_type.? != *Table) @compileError(error_message);
-        if (info.args[1].arg_type.? != mem.Allocator) @compileError(error_message);
+        if (info.params.len != 2) @compileError(error_message);
+        if (info.params[0].type.? != *Table) @compileError(error_message);
+        if (info.params[1].type.? != mem.Allocator) @compileError(error_message);
         if (info.return_type.? != void) @compileError(error_message);
     }
 
@@ -515,10 +515,10 @@ fn validateTableType(comptime Table: type) void {
 
         const info = @typeInfo(@TypeOf(Table.buildBestIndex)).Fn;
 
-        if (info.args.len != 3) @compileError(error_message);
-        if (info.args[0].arg_type.? != *Table) @compileError(error_message);
-        if (info.args[1].arg_type.? != *VTabDiagnostics) @compileError(error_message);
-        if (info.args[2].arg_type.? != *BestIndexBuilder) @compileError(error_message);
+        if (info.params.len != 3) @compileError(error_message);
+        if (info.params[0].type.? != *Table) @compileError(error_message);
+        if (info.params[1].type.? != *VTabDiagnostics) @compileError(error_message);
+        if (info.params[2].type.? != *BestIndexBuilder) @compileError(error_message);
         if (info.return_type.? != Table.BuildBestIndexError!void) @compileError(error_message);
     }
 
@@ -541,7 +541,7 @@ fn parseModuleArguments(allocator: mem.Allocator, argc: c_int, argv: [*c]const [
     var res = try allocator.alloc(ModuleArgument, @intCast(usize, argc));
     errdefer allocator.free(res);
 
-    for (res) |*marg, i| {
+    for (res, 0..) |*marg, i| {
         // The documentation of sqlite says each string in argv is null-terminated
         const arg = mem.sliceTo(argv[i], 0);
 
@@ -840,7 +840,7 @@ pub fn VirtualTable(
             const size = @intCast(usize, argc);
 
             var res = try allocator.alloc(FilterArg, size);
-            for (res) |*item, i| {
+            for (res, 0..) |*item, i| {
                 item.* = .{
                     .value = argv[i],
                 };
@@ -1276,7 +1276,7 @@ test "parse module arguments" {
     const allocator = arena.allocator();
 
     var args = try allocator.alloc([*c]const u8, 20);
-    for (args) |*arg, i| {
+    for (args, 0..) |*arg, i| {
         const tmp = try fmt.allocPrintZ(allocator, "arg={d}", .{i});
         arg.* = @ptrCast([*c]const u8, tmp);
     }
@@ -1288,7 +1288,7 @@ test "parse module arguments" {
     );
     try testing.expectEqual(@as(usize, 20), res.len);
 
-    for (res) |arg, i| {
+    for (res, 0..) |arg, i| {
         try testing.expectEqualStrings("arg", arg.kv.key);
         try testing.expectEqual(i, try fmt.parseInt(usize, arg.kv.value, 10));
     }