chore: replace zlinter with the default zig linter (#33)

Author: ch4r10t33r

.github/workflows/ci.yml

@@ -29,7 +29,7 @@ jobs:
       - name: Verify Zig installation
         run: zig version
 
-      - name: Run lint
+      - name: Run lint (zig fmt --check)
         run: zig build lint
 
   test:
@@ -72,4 +72,4 @@ jobs:
           version: 0.14.1
 
       - name: Build library
-        run: zig build-lib src/root.zig --name hash_zig
+        run: zig build

build.zig

@@ -3,6 +3,7 @@ const std = @import("std");
 pub fn build(b: *std.Build) void {
     const target = b.standardTargetOptions(.{});
     const optimize = b.standardOptimizeOption(.{});
+    const enable_docs = b.option(bool, "docs", "Enable docs generation") orelse false;
 
     // Create the module
     const hash_zig_module = b.addModule("hash-zig", .{
@@ -19,21 +20,10 @@ pub fn build(b: *std.Build) void {
     });
     b.installArtifact(lib);
 
-    // Lint (using zlinter)
-    const zlinter = @import("zlinter");
-    const lint_step = b.step("lint", "Run zlinter");
-    lint_step.dependOn(step: {
-        var builder = zlinter.builder(b, .{});
-        builder.addPaths(.{
-            .include = &.{ b.path("src/"), b.path("examples/"), b.path("test/") },
-        });
-        builder.addRule(.{ .builtin = .field_naming }, .{});
-        builder.addRule(.{ .builtin = .declaration_naming }, .{});
-        builder.addRule(.{ .builtin = .function_naming }, .{});
-        builder.addRule(.{ .builtin = .no_unused }, .{});
-        builder.addRule(.{ .builtin = .no_deprecated }, .{});
-        break :step builder.build();
-    });
+    // Lint (using built-in formatter in check mode)
+    const lint_cmd = b.addSystemCommand(&.{ "zig", "fmt", "--check", "src", "examples" });
+    const lint_step = b.step("lint", "Run lint (zig fmt --check)");
+    lint_step.dependOn(&lint_cmd.step);
 
     // Tests
     const lib_unit_tests = b.addTest(.{
@@ -177,12 +167,14 @@ pub fn build(b: *std.Build) void {
     // const optimized_benchmark_step = b.step("optimized-benchmark", "Run optimized performance benchmark");
     // optimized_benchmark_step.dependOn(&run_optimized_benchmark.step);
 
-    // Documentation
-    const docs_step = b.step("docs", "Generate documentation");
-    const install_docs = b.addInstallDirectory(.{
-        .source_dir = lib.getEmittedDocs(),
-        .install_dir = .prefix,
-        .install_subdir = "docs",
-    });
-    docs_step.dependOn(&install_docs.step);
+    // Documentation (opt-in to avoid enabling -femit-docs on default builds)
+    if (enable_docs) {
+        const docs_step = b.step("docs", "Generate documentation");
+        const install_docs = b.addInstallDirectory(.{
+            .source_dir = lib.getEmittedDocs(),
+            .install_dir = .prefix,
+            .install_subdir = "docs",
+        });
+        docs_step.dependOn(&install_docs.step);
+    }
 }

build.zig.zon

@@ -4,12 +4,7 @@
     .fingerprint = 0xc2f8b6b2acaee93c,
     .minimum_zig_version = "0.14.1",
 
-    .dependencies = .{
-        .zlinter = .{
-            .url = "git+https://github.com/kurtwagner/zlinter?ref=0.14.x#61d13720da00e47855d67397a8a36a7827aba165",
-            .hash = "1220ef236272ded3155b3fa6e198f3cf57c9c82606fcb18ca4f76e1b2242fad2dfd2",
-        },
-    },
+    .dependencies = .{},
 
     .paths = .{
         "build.zig",

examples/profiling.zig

@@ -21,52 +21,48 @@ pub fn main() !void {
 
     // Profile individual WOTS operations
     std.debug.print("--- Single WOTS Operation Profile ---\n", .{});
-    
+
     const wots_priv_start_ts = std.time.nanoTimestamp();
     const priv_key = try sig_scheme.wots.generatePrivateKey(allocator, &seed, 0);
     const wots_priv_end_ts = std.time.nanoTimestamp();
-    
+
     const pub_key = try sig_scheme.wots.generatePublicKey(allocator, priv_key);
     const wots_pub_end_ts = std.time.nanoTimestamp();
-    
+
     const priv_time = @as(f64, @floatFromInt(wots_priv_end_ts - wots_priv_start_ts)) / 1_000_000.0;
     const pub_time = @as(f64, @floatFromInt(wots_pub_end_ts - wots_priv_end_ts)) / 1_000_000.0;
-    
+
     std.debug.print("  generatePrivateKey: {d:.3} ms\n", .{priv_time});
     std.debug.print("  generatePublicKey:  {d:.3} ms\n", .{pub_time});
     std.debug.print("  Total per leaf:     {d:.3} ms\n\n", .{priv_time + pub_time});
-    
+
     for (priv_key) |k| allocator.free(k);
     allocator.free(priv_key);
     allocator.free(pub_key);
 
     // Profile hash operations
     std.debug.print("--- Hash Operation Profile ---\n", .{});
     const test_data = "test data for hashing";
-    
+
     const hash_start_ts = std.time.nanoTimestamp();
     const hash_result = try sig_scheme.wots.hash.hash(allocator, test_data, 0);
     const hash_end_ts = std.time.nanoTimestamp();
     allocator.free(hash_result);
-    
+
     const hash_time = @as(f64, @floatFromInt(hash_end_ts - hash_start_ts)) / 1_000_000.0;
     std.debug.print("  Single hash call: {d:.3} ms\n\n", .{hash_time});
 
     // Calculate expected times
     const num_leaves = @as(usize, 1) << @intCast(params.tree_height);
     const chain_length = @as(u32, 1) << @intCast(@ctz(params.winternitz_w));
-    
+
     std.debug.print("--- Theoretical Breakdown for 1,024 leaves ---\n", .{});
     std.debug.print("  Chain length: {}\n", .{chain_length});
     std.debug.print("  Chains per leaf: ~86\n", .{});
     std.debug.print("  Hashes per leaf: ~86 * {} = ~{}\n", .{ chain_length, 86 * chain_length });
     std.debug.print("  Total hashes: 1024 * {} = ~{}\n", .{ 86 * chain_length, 1024 * 86 * chain_length });
-    std.debug.print("  Expected hash time: {d:.1} seconds\n", .{
-        @as(f64, @floatFromInt(1024 * 86 * chain_length)) * hash_time / 1000.0
-    });
-    std.debug.print("  Expected leaf gen: {d:.1} seconds\n\n", .{
-        @as(f64, @floatFromInt(num_leaves)) * (priv_time + pub_time) / 1000.0
-    });
+    std.debug.print("  Expected hash time: {d:.1} seconds\n", .{@as(f64, @floatFromInt(1024 * 86 * chain_length)) * hash_time / 1000.0});
+    std.debug.print("  Expected leaf gen: {d:.1} seconds\n\n", .{@as(f64, @floatFromInt(num_leaves)) * (priv_time + pub_time) / 1000.0});
 
     // Now do full keygen with timing
     std.debug.print("--- Full Key Generation ---\n", .{});
@@ -85,4 +81,3 @@ pub fn main() !void {
     std.debug.print("  Merkle tree: ~{d:.1}%\n", .{100.0 - leaf_gen_percent});
     std.debug.print("  Other overhead: ~{d:.1}%\n", .{@max(0.0, 100.0 - leaf_gen_percent - 10.0)});
 }
-

src/merkle.zig

@@ -132,7 +132,7 @@ pub const MerkleTree = struct {
                 defer allocator.free(threads);
                 // Spawn workers
                 for (0..num_threads) |t| {
-                    threads[t] = try std.Thread.spawn(.{}, nodeWorker, .{ &ctx });
+                    threads[t] = try std.Thread.spawn(.{}, nodeWorker, .{&ctx});
                 }
                 // Join
                 for (threads) |th| th.join();

src/poseidon2/fields/koalabear/montgomery.zig

@@ -1,3 +1,2 @@
 // KoalaBear field: p = 2^31 - 2^24 + 1 = 127 * 2^24 + 1 = 2130706433 = 0x7f000001
 pub const montgomery_field = @import("../generic_montgomery.zig").MontgomeryField31(127 * (1 << 24) + 1);
-

src/poseidon2/poseidon2.zig

@@ -40,7 +40,7 @@ pub fn Poseidon2(
             permutation(&state);
             var result: [output_len]F.FieldElem = undefined;
             inline for (0..output_len) |i| {
-                // Add input[i] to montgomery form state[i] 
+                // Add input[i] to montgomery form state[i]
                 var input_mont: F.MontFieldElem = undefined;
                 F.toMontgomery(&input_mont, input[i]);
                 F.add(&state[i], state[i], input_mont);

src/poseidon2/root.zig

@@ -13,4 +13,3 @@ pub const koalabear16 = @import("instances/koalabear16.zig");
 // Re-export the main types (snake_case per lint)
 pub const poseidon2_koalabear16 = koalabear16.poseidon2_type;
 pub const koalabear_field = koalabear_montgomery.montgomery_field;
-