json.reader

A located error at the cursor.

Advance past whitespace.

A hand-written inline check for "the next byte is not whitespace" before this call was measured and was slower on every shape: the shared scan already opens with a scalar prelude for exactly that case, and the extra branch only added work.

The next significant byte, or 0 at end of input.

Zero is safe as the end marker: a NUL outside a string is not in the grammar, so every caller that compares against a real byte rejects it anyway.

Nothing but whitespace may follow the top-level value.

Advance to the next object member. False at the closing brace.

Each byte is looked at once. The previous shape called peek three times per member, and every call re-ran the whitespace scan from a position where nothing had been consumed since the last one; the byte it returned was already in a register.

Advance to the next array element. False at the closing bracket.

Consume an object key and its colon, without materializing it.

A key is compared against a field name far more often than it is kept, and building a String for each comparison is what made the old read path allocate on the order of the square of the field count per record.

Whether an unescaped key spells name.

Takes self immutably and the name as a parameter, both for the same reason: this runs inside a comptime-unrolled loop over a struct's fields, and a method that could mutate the reader forces the compiler to reload its span and position after every call in that loop. With the name known at compile time the length test is a comparison against a constant, which settles most fields without looking at a byte.

Whether a key spells name, expanding escapes if it has any.

The escaped case is why this takes self mutably: the key is unescaped into the reader's scratch buffer before comparing, so that a key written "a" still matches a field named a. Callers on the hot path go through key_matches and only reach here when the key actually carries an escape.

A key as a String, for the cases that must keep it.

Consume null if that is what comes next.

Read an integer field.

Most integers in a document are a handful of digits, and reaching them through the full number scanner costs four outlined calls: the scanner walks the digits once to check the grammar and again to accumulate, peeks for an eight-digit SWAR block that a short integer never has, and hands back a forty-eight byte token that the range check then unpacks.

The path below commits only when it has itself established the whole token: an optional minus, a leading digit in 1-9 so that anything starting 0 defers, at most eighteen digits so the accumulator cannot overflow, and a terminator that cannot continue a number. Everything else -- 0, -0, a fraction, an exponent, a leading zero, nineteen digits or more -- falls through to the scanner, which stays the only authority on the grammar, the messages and the offsets they carry.

Consume one value without binding it. Returns its byte range.

Used for a member no field wants, and to hand a subtree to a type that parses itself. Validating rather than merely counting brackets matters: an unknown field is still part of the document, and accepting rubbish inside it would mean two readers of the same bytes disagree about whether they are JSON.