tiny.pluck.source_identity

1const std = @import("std");2const Allocator = std.mem.Allocator;34const pexpr = @import("pexpr.zig");5const Symbol = pexpr.Symbol;6const PExpr = pexpr.PExpr;78pub const DefinitionId = struct {9    name_hash: u64,10    name: Symbol,1112    const Self = @This();1314    pub fn init(name: Symbol) Self {15        var hasher = std.hash.Wyhash.init(0);16        hasher.update(name);17        return Self{18            .name_hash = hasher.final(),19            .name = name,20        };21    }2223    pub fn hash(self: Self) u64 {24        return self.name_hash;25    }2627    pub fn eql(a: Self, b: Self) bool {28        return a.name_hash == b.name_hash and std.mem.eql(u8, a.name, b.name);29    }30};3132pub const DefinitionIdContext = struct {33    pub fn hash(_: DefinitionIdContext, key: DefinitionId) u64 {34        return key.hash();35    }3637    pub fn eql(_: DefinitionIdContext, a: DefinitionId, b: DefinitionId) bool {38        return a.eql(b);39    }40};4142pub const ContentHash = struct {43    hash: u64,4445    const Self = @This();4647    pub fn fromExpr(expr: *const PExpr) Self {48        var hasher = std.hash.Wyhash.init(0xDEF1717100);49        hashExprStructure(&hasher, expr);50        return Self{ .hash = hasher.final() };51    }5253    pub fn fromSource(source: []const u8) Self {54        var hasher = std.hash.Wyhash.init(0xDEF1717100);55        var prev_was_space = false;56        for (source) |c| {57            if (std.ascii.isWhitespace(c)) {58                if (!prev_was_space) {59                    hasher.update(" ");60                    prev_was_space = true;61                }62            } else {63                hasher.update(&[_]u8{c});64                prev_was_space = false;65            }66        }67        return Self{ .hash = hasher.final() };68    }6970    pub fn eql(a: Self, b: Self) bool {71        return a.hash == b.hash;72    }7374    fn hashExprStructure(hasher: *std.hash.Wyhash, expr: *const PExpr) void {75        const head_tag = @backingInt(std.meta.activeTag(expr.head));76        hasher.update(std.mem.asBytes(&head_tag));7778        switch (expr.head) {79            .var_ref => |v| hasher.update(v.name),80            .defined => |d| hasher.update(d.name),8182            .abs => |a| hasher.update(a.var_name),8384            .construct => |c| hasher.update(c.constructor),8586            .case_of => |c| {87                for (c.branches) |branch| {88                    hasher.update(branch.constructor);89                    for (branch.args) |arg| {90                        hasher.update(arg);91                    }92                }93            },9495            .type_def => |t| {96                hasher.update(t.type_name);97                for (t.constructors) |ctor| {98                    hasher.update(ctor.name);99                    for (ctor.args) |arg| {100                        hasher.update(arg);101                    }102                }103            },104105            .const_native => |n| {106                switch (n) {107                    .float => |f| {108                        const bits: u64 = @bitCast(f);109                        hasher.update(std.mem.asBytes(&bits));110                    },111                    .int => |i| hasher.update(std.mem.asBytes(&i)),112                    .symbol => |s| hasher.update(s),113                    .bool_val => |b| hasher.update(std.mem.asBytes(&b)),114                }115            },116117            .app,118            .y_combinator,119            .flip,120            .factor,121            .native_eq,122            .get_args,123            .get_constructor,124            .pbool,125            .get_config,126            .mk_int,127            .mk_int_weighted,128            .int_dist_eq,129            .print_op,130            .f_div,131            .f_mul,132            .f_add,133            .f_sub,134            .error_op,135            => {},136        }137138        for (expr.args) |arg| {139            hashExprStructure(hasher, arg);140        }141    }142};143144pub const SourceThunkId = struct {145    def_id: DefinitionId,146    callstack_hash: u64,147    position_hash: u64,148149    const Self = @This();150151    pub fn init(def_name: Symbol, callstack: []const i32, expr: *const PExpr) Self {152        var cs_hasher = std.hash.Wyhash.init(0);153        cs_hasher.update(std.mem.sliceAsBytes(callstack));154155        var pos_hasher = std.hash.Wyhash.init(0xB051710);156        ContentHash.hashExprStructure(&pos_hasher, expr);157158        return Self{159            .def_id = DefinitionId.init(def_name),160            .callstack_hash = cs_hasher.final(),161            .position_hash = pos_hasher.final(),162        };163    }164165    pub fn initQuery(callstack: []const i32, expr: *const PExpr) Self {166        return init("__query__", callstack, expr);167    }168169    pub fn hash(self: Self) u64 {170        var h = std.hash.Wyhash.init(0);171        h.update(std.mem.asBytes(&self.def_id.name_hash));172        h.update(std.mem.asBytes(&self.callstack_hash));173        h.update(std.mem.asBytes(&self.position_hash));174        return h.final();175    }176177    pub fn eql(a: Self, b: Self) bool {178        return a.def_id.eql(b.def_id) and179            a.callstack_hash == b.callstack_hash and180            a.position_hash == b.position_hash;181    }182};183184pub const SourceThunkIdContext = struct {185    pub fn hash(_: SourceThunkIdContext, key: SourceThunkId) u64 {186        return key.hash();187    }188189    pub fn eql(_: SourceThunkIdContext, a: SourceThunkId, b: SourceThunkId) bool {190        return a.eql(b);191    }192};193194test "DefinitionId stability" {195    const id1 = DefinitionId.init("foo");196    const id2 = DefinitionId.init("foo");197    const id3 = DefinitionId.init("bar");198199    try std.testing.expect(id1.eql(id2));200    try std.testing.expectEqual(id1.hash(), id2.hash());201    try std.testing.expect(!id1.eql(id3));202}203204test "ContentHash from expression" {205    const allocator = std.testing.allocator;206207    const expr1 = try PExpr.init(allocator, .{ .const_native = .{ .float = 42.0 } });208    defer expr1.deinit(allocator);209210    const expr2 = try PExpr.init(allocator, .{ .const_native = .{ .float = 42.0 } });211    defer expr2.deinit(allocator);212213    const expr3 = try PExpr.init(allocator, .{ .const_native = .{ .float = 43.0 } });214    defer expr3.deinit(allocator);215216    const hash1 = ContentHash.fromExpr(expr1);217    const hash2 = ContentHash.fromExpr(expr2);218    const hash3 = ContentHash.fromExpr(expr3);219220    try std.testing.expect(hash1.eql(hash2));221    try std.testing.expect(!hash1.eql(hash3));222}223224test "SourceThunkId stability across re-parse" {225    const allocator = std.testing.allocator;226227    const expr1 = try PExpr.init(allocator, .{ .const_native = .{ .float = 0.5 } });228    defer expr1.deinit(allocator);229230    const expr2 = try PExpr.init(allocator, .{ .const_native = .{ .float = 0.5 } });231    defer expr2.deinit(allocator);232233    const callstack: []const i32 = &[_]i32{ 1, 2, 3 };234235    const id1 = SourceThunkId.init("mydef", callstack, expr1);236    const id2 = SourceThunkId.init("mydef", callstack, expr2);237238    try std.testing.expect(id1.eql(id2));239    try std.testing.expectEqual(id1.hash(), id2.hash());240}

1pub const source_identity = @import("identity.zig");