use sealmap_model::Fingerprint;
pub const ALGORITHM: &str = "sm1";
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum Delim {
Paren,
Bracket,
Brace,
None,
}
impl Delim {
fn byte(self) -> Option<u8> {
match self {
Self::Paren => Some(b'('),
Self::Bracket => Some(b'['),
Self::Brace => Some(b'{'),
Self::None => None,
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Token<'a> {
Ident(&'a str),
Punct(char),
Literal(&'a str),
Open(Delim),
Close(Delim),
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Kind {
Sig,
Body,
}
impl Kind {
fn context(self) -> &'static str {
match self {
Self::Sig => "sealmap sm1 2026-10 symbol signature fingerprint",
Self::Body => "sealmap sm1 2026-10 symbol body fingerprint",
}
}
}
#[derive(Debug, Clone)]
pub struct Fingerprinter {
hasher: blake3::Hasher,
}
mod tag {
pub const IDENT: u8 = b'i';
pub const PUNCT: u8 = b'p';
pub const LITERAL: u8 = b'l';
pub const OPEN: u8 = b'o';
pub const CLOSE: u8 = b'c';
pub const SECTION: u8 = b's';
pub const FINGERPRINT: u8 = b'f';
}
impl Fingerprinter {
pub fn new(kind: Kind) -> Self {
Self { hasher: blake3::Hasher::new_derive_key(kind.context()) }
}
pub fn sig() -> Self {
Self::new(Kind::Sig)
}
pub fn body() -> Self {
Self::new(Kind::Body)
}
fn record(&mut self, tag: u8, payload: &[u8]) {
let len = u32::try_from(payload.len()).unwrap_or(u32::MAX);
self.hasher.update(&[tag]);
self.hasher.update(&len.to_le_bytes());
self.hasher.update(payload);
}
pub fn token(&mut self, token: Token<'_>) {
match token {
Token::Ident(s) => self.record(tag::IDENT, s.as_bytes()),
Token::Punct(c) => self.record(tag::PUNCT, c.encode_utf8(&mut [0; 4]).as_bytes()),
Token::Literal(s) => {
if s.contains('\r') {
let normalised = s.replace("\r\n", "\n").replace('\r', "\n");
self.record(tag::LITERAL, normalised.as_bytes());
} else {
self.record(tag::LITERAL, s.as_bytes());
}
}
Token::Open(d) => {
if let Some(b) = d.byte() {
self.record(tag::OPEN, &[b]);
}
}
Token::Close(d) => {
if let Some(b) = d.byte() {
self.record(tag::CLOSE, &[b]);
}
}
}
}
pub fn ident(&mut self, s: &str) {
self.token(Token::Ident(s));
}
pub fn punct(&mut self, c: char) {
self.token(Token::Punct(c));
}
pub fn literal(&mut self, s: &str) {
self.token(Token::Literal(s));
}
pub fn open(&mut self, d: Delim) {
self.token(Token::Open(d));
}
pub fn close(&mut self, d: Delim) {
self.token(Token::Close(d));
}
pub fn section(&mut self, label: &str) {
self.record(tag::SECTION, label.as_bytes());
}
pub fn fingerprint(&mut self, f: Fingerprint) {
self.record(tag::FINGERPRINT, f.as_bytes());
}
pub fn finish(&self) -> Fingerprint {
Fingerprint::from_blake3(&self.hasher.finalize())
}
}
#[cfg(test)]
mod tests {
use super::*;
fn of(kind: Kind, tokens: &[Token<'_>]) -> Fingerprint {
let mut fp = Fingerprinter::new(kind);
for t in tokens {
fp.token(*t);
}
fp.finish()
}
#[test]
fn golden_values() {
assert_eq!(ALGORITHM, "sm1");
assert_eq!(of(Kind::Sig, &[]).to_string(), "blake3-16:b0dfa318e9fc9bb5b577c6f8be0aa206");
assert_eq!(of(Kind::Body, &[]).to_string(), "blake3-16:6d9fd803f137d8db3ae28e1ad8e4c67c");
let add = [
Token::Open(Delim::Brace),
Token::Ident("a"),
Token::Punct('+'),
Token::Literal("1"),
Token::Close(Delim::Brace),
];
assert_eq!(of(Kind::Body, &add).to_string(), "blake3-16:a6253eb7723698ef6076dae4fbc0dbbc");
let mut fp = Fingerprinter::sig();
fp.section("name");
fp.ident("add");
fp.fingerprint(of(Kind::Body, &add));
assert_eq!(fp.finish().to_string(), "blake3-16:e4cc87578f4afde856d1051c846f075f");
}
#[test]
fn token_boundaries_and_kinds_are_hashed() {
use Token::*;
let pairs: [(&[Token<'_>], &[Token<'_>]); 6] = [
(&[Ident("ab")], &[Ident("a"), Ident("b")]),
(&[Ident("a")], &[Literal("a")]),
(&[Punct('-'), Punct('>')], &[Punct('>'), Punct('-')]),
(&[Open(Delim::Paren), Close(Delim::Paren)], &[Open(Delim::Bracket), Close(Delim::Bracket)]),
(
&[Open(Delim::Paren), Ident("a"), Close(Delim::Paren), Ident("b")],
&[Open(Delim::Paren), Ident("a"), Ident("b"), Close(Delim::Paren)],
),
(&[Literal("\"a b\"")], &[Literal("\"a b\"")]),
];
for (a, b) in pairs {
assert_ne!(of(Kind::Body, a), of(Kind::Body, b), "{a:?} vs {b:?}");
}
assert_ne!(of(Kind::Sig, &[Ident("a")]), of(Kind::Body, &[Ident("a")]));
}
#[test]
fn normalisation() {
use Token::*;
assert_eq!(of(Kind::Body, &[Literal("\"a\r\nb\""),]), of(Kind::Body, &[Literal("\"a\nb\"")]));
assert_eq!(of(Kind::Body, &[Literal("\"a\rb\""),]), of(Kind::Body, &[Literal("\"a\nb\"")]));
assert_eq!(of(Kind::Body, &[Open(Delim::None), Ident("x"), Close(Delim::None)]), of(Kind::Body, &[Ident("x")]));
}
#[test]
fn sections_separate_parts() {
let mut a = Fingerprinter::sig();
a.section("generics");
a.ident("T");
a.section("params");
let mut b = Fingerprinter::sig();
b.section("generics");
b.section("params");
b.ident("T");
assert_ne!(a.finish(), b.finish());
}
}