Make Hakuzaru Great Again #22

2026-05-10T12:34:00+09:00

zxq9 commented

2026-05-10 12:34:00 +09:00

This is a significant refactor, feature enhancement and set of bug and documentation fixes -- all in one. v0.9.x is cray cray.

zxq9 added 40 commits 2026-05-10 12:34:01 +09:00

split AACI out of hz.erl d2163c1ff8

So far the interface to hz.erl is mostly unchanged, apart from prepare_aaci/1

Maybe prepare_aaci should be re-exported, but using it is exactly in line with the
'inconvenient but more flexible primitives' that hz_aaci.erl is meant to represent,
so, maybe that is a fine place to have to go for it, dunno.

split coerce/3 into two functions 3da9bd570b

Also renamed coerce_bindings to erlang_args_to_fate, to match.

use lists:unzip/1 4f1958b210

Just a little thing I noticed could be improved.

Rename get_function_signature 6f5525afcf

hz_aaci:aaci_get_function_signature is a bit redundant.

set up parsing structure 97e32574c4

We tokenize, and then do the simplest possible recursive descent.

We don't want to evaluate anything, so infix operators are out,
meaning no shunting yard or tree rearranging or LR(1) shenanigans
are necessary, just write the code.

If we want to 'peek', just take the next token, and pass it around
from that point on, until it can actually be consumed.

List parsing 3f1c9bd626

Slowly chipping away at cases...

Map parsing 56e63051bc

Record parsing 6f02d4c4e6

Tuple parsing 7df04a81be

Variant parsing 4f2a3c6c6f

Infer correct values for tests automatically 2bf384ca82

Now tests compare the literal parser against the output of the
compiler. The little example contracts we are compiling for the
AACI already had the FATE value in them, in the form of the
instruction
	{'RETURNR', {immediate, FateValue}}
so we just extract that and use it for the tests.

Bytes lexing f1696e2b9e

I don't handle underscores in bytes correctly... Nor in integers, for that matter.

Handle underscores in integers/bytes fe182a5233

This forces us to test for alpha/num/hex enough times that it's now worth making macros for these things.

Calculate scalar values during lexing 966b4b2748

This saves some effort and probably some performance for things like integers, but I'm mainly doing this in anticipation of string literals, because it would just be ridiculous to read code that lexes string literals twice.

Parse strings 49cd8b6687

Singleton record/tuple parsing. 272ed01fdc

Records are a simple case to detect and handle correctly.

Tuples took an entire rewrite of the little tuple parsing bit of the code.

Parse long hex escape codes 17f635af61

This doesn't work super consistently in the compiler, for codepoints above 127, but it should work fine for us, so, oh well!

Fix lexer row/column calculations. 493bdb990c

Parse address literals. a695c21fc9

Also signatures.

remove 'tk' atom from file positions bb4bcbb7de

Handle token/parse errors more carefully d014ae0982

Parse qualified names. 3838a7e3c5

This seemed like it was going to be insanely insanely complex, but
then it turns out the compiler doesn't accept spaces in qualified
names, so I can just dump periods in the lexer and hit it with
string:split/3. Easy.

Adjusting a few calls. 6c172c4783

Refine tuple parsing errors 60985130cb

There are four major fixes here:
1. some eof tokens were being pattern matched with the wrong arity
2. tuples that are too long actually speculatively parse as an untyped tuple, and then complain that there were too many elements,
3. singleton tuples with a trailing comma are now handled differently to grouping parentheses, consistently between typed and untyped logic
4. the extra return values used to detect untyped singleton tuples are also used to pass the close paren position, so that too_many_elements can report the correct file position too.

Point 4. also completely removes the need for tracking open paren positions that I was doing, and that I thought I would need to do even more of in the ambiguous-open-paren-stack case.

Update comments, add fate and sophia tagged args efe0a64056

Merge branch 'parser' of ssh://git.qpq.swiss:21203/QPQ-AG/hakuzaru into parser a1fc5f19fa

bool/char literals 9bc0ffafd1

Character literals were the main complexity here, but I threw booleans in as well, since that covers all the major literals.

typecheck bits 78c9c67f38

Sophia bitstrings aren't really something you initialize manually, so we have to make up a literal format for them. Failing that, we just accept arbitrary integers and bytearrays as bitstrings.

Pretty print Sophia expressions. a0fbeebcdb

I think all of the tests roundtrip now, so if my parser was thorough, the pretty printer should be as thorough.

add more format options to decode_bytearray ddec3bfa74

I reversed the argument order here, since the Format option is sort of kind of almost optional, but I am not sure if that was a good idea.

Minor doc and style edits f277e79096

Merge branch 'parser' of ssh://git.qpq.swiss:21203/QPQ-AG/hakuzaru into parser bda4e89e58

Fill AACI and coerce type specs 540b2c513b

Any error reasons or paths are just term() still, and ACI doesn't have a defined spec in the compiler, so whatever, but the AACI types, the erlang representation of terms, and the four different kinds of coerce function are all spec'd now.

Also some internal type substitution functions were given types, just in the hopes of catching some errors, but dyalizer doesn't seem to complain at all no matter how badly I break my code. Strange approach to making a type system, but oh well.

Unify call arg order between call and create fd8766a249

verup 9f02f73dbd

WIP 695e7e4828

derp 02945dd10d

WIP 7fc3cd00da

base64 -> bytearray encoding fd2158a465

Differentiate between source return types cd4f6a56a5

zxq9 added 1 commit 2026-05-10 13:16:36 +09:00

Fix list -> binary arg c54c0db17a

zxq9 added 1 commit 2026-05-10 15:02:19 +09:00

Let non-zx projects call contract_create* c9ead44aa2

zxq9 added 2 commits 2026-05-10 15:10:03 +09:00