@axpecter/lync 2.3.3 → 3.0.0

package/shape/emit/Leaf.luau

@@ -0,0 +1,462 @@
+--!strict
+--!native
+--!optimize 2
+-- Every value that is not a bit region, as the pair of closures that writes it and reads it back.
+
+local Bits = require (script.Parent.Parent.Parent.kernel.Bits)
+local Bytes = require (script.Parent.Parent.Parent.wire.Bytes)
+local Catalog = require (script.Parent.Parent.Parent.kernel.Catalog)
+local Ir = require (script.Parent.Parent.Ir)
+local Log = require (script.Parent.Parent.Parent.kernel.Log)
+local Protocol = require (script.Parent.Parent.Parent.wire.Protocol)
+local Serial = require (script.Parent.Parent.Serial)
+local Types = require (script.Parent.Parent.Parent.Types)
+local Varint = require (script.Parent.Parent.Parent.wire.Varint)
+local Word = require (script.Parent.Word)
+
+local Leaf = {}
+
+-- Constants -----------------------------------------------------------
+
+const BYTE = Protocol.BYTE_BITS
+const EXACT = Protocol.EXACT
+
+-- The widths a whole number of bytes is read and written in, and the value one word carries.
+const PAIR = 2
+const TRIO = PAIR + 1
+const WORD = 4
+const HALF = 65536
+const HIGH = 2 ^ (WORD * BYTE)
+
+-- The slot a reference nobody made takes, which is none, since the array it indexes starts at one.
+const NOTHING = 0
+
+-- Types ---------------------------------------------------------------
+
+-- What a node is told about itself, which is where it is and what it wanted, already in words.
+type Named = {
+    path: string,
+    wanted: string,
+    pathId: number,
+    expectId: number,
+}
+
+-- Private -------------------------------------------------------------
+
+local function named (tag: Ir.Tag, paths: Serial.Interner, expected: Serial.Interner): Named
+    return {
+        path = paths.texts[tag.pathId],
+        wanted = expected.texts[tag.expectId],
+        pathId = tag.pathId,
+        expectId = tag.expectId,
+    }
+end
+
+--[[
+    A value the schema has no place for, as the line the caller reads. The same sentence a drop
+    reads as, because a caller holds one vocabulary for what their schema wanted whether the value
+    that did not fit was theirs going out or somebody else's coming in.
+]]
+local function refuse (of: Named, got: any): never return Word.refused (of.path, of.wanted, got) end
+
+-- Bytes nobody here wrote, as the two numbers the boundary reads a line back out of.
+local function reject (code: Catalog.Code, of: Named, got: any)
+    Log.reject (code, { pathId = of.pathId, expectId = of.expectId, got = got })
+end
+
+-- A whole number of bytes, little end first, for every field that is one.
+local function laid (b: buffer, at: number, bytes: number, value: number)
+    if bytes <= WORD then
+        if bytes == 0 then return end
+        if bytes == 1 then return buffer.writeu8 (b, at, value) end
+        if bytes == PAIR then return buffer.writeu16 (b, at, value) end
+        if bytes == TRIO then
+            buffer.writeu16 (b, at, value % HALF)
+            return buffer.writeu8 (b, at + PAIR, value // HALF)
+        end
+        return buffer.writeu32 (b, at, value)
+    end
+
+    buffer.writeu32 (b, at, value % HIGH)
+
+    local high = value // HIGH
+    if bytes == 5 then return buffer.writeu8 (b, at + WORD, high) end
+    if bytes == 6 then return buffer.writeu16 (b, at + WORD, high) end
+
+    buffer.writeu16 (b, at + WORD, high % HALF)
+    buffer.writeu8 (b, at + WORD + PAIR, high // HALF)
+end
+
+local function taken (b: buffer, at: number, bytes: number): number
+    if bytes <= WORD then
+        if bytes == 0 then return 0 end
+        if bytes == 1 then return buffer.readu8 (b, at) end
+        if bytes == PAIR then return buffer.readu16 (b, at) end
+        if bytes == TRIO then
+            return buffer.readu16 (b, at) + buffer.readu8 (b, at + PAIR) * HALF
+        end
+        return buffer.readu32 (b, at)
+    end
+
+    local low = buffer.readu32 (b, at)
+    if bytes == 5 then return low + buffer.readu8 (b, at + WORD) * HIGH end
+    if bytes == 6 then return low + buffer.readu16 (b, at + WORD) * HIGH end
+
+    local high = buffer.readu16 (b, at + WORD) + buffer.readu8 (b, at + WORD + PAIR) * HALF
+    return low + high * HIGH
+end
+
+-- Public --------------------------------------------------------------
+
+-- Elements of one width with nothing between them, which is the 24-bit law's whole point.
+function Leaf.packed (
+    b: buffer,
+    at: number,
+    width: number,
+    count: number,
+    indices: { number }
+): number
+    local acc, used = 0, 0
+
+    for index = 1, count do
+        acc = bit32.bor (acc, bit32.lshift (indices[index], used))
+        used += width
+
+        while used >= BYTE do
+            buffer.writeu8 (b, at, bit32.band (acc, 0xFF))
+            at += 1
+            acc = bit32.rshift (acc, BYTE)
+            used -= BYTE
+        end
+    end
+
+    if used == 0 then return at end
+
+    buffer.writeu8 (b, at, acc)
+    return at + 1
+end
+
+--[[
+    The same run, taken apart. The bits left over when the last element is out are the pad the
+    stream aligns on, and they are held to being zero: padding that could differ would make two
+    encodings of one value, which is what the ordering of map keys rests on not being possible.
+]]
+function Leaf.unpacked (
+    b: buffer,
+    at: number,
+    width: number,
+    count: number,
+    into: { number }
+): (number, boolean)
+    local acc, used = 0, 0
+    local mask = bit32.lshift (1, width) - 1
+
+    for index = 1, count do
+        while used < width do
+            acc = bit32.bor (acc, bit32.lshift (buffer.readu8 (b, at), used))
+            at += 1
+            used += BYTE
+        end
+
+        into[index] = bit32.band (acc, mask)
+        acc = bit32.rshift (acc, width)
+        used -= width
+    end
+
+    return at, acc == 0
+end
+
+-- An IEEE span, which has a place for every bit pattern a double takes and so refuses no number.
+function Leaf.float (
+    of: Ir.Float,
+    paths: Serial.Interner,
+    expected: Serial.Interner
+): (Ir.Write, Ir.Read)
+    local at = named (of.tag, paths, expected)
+    local bytes = of.maxBytes
+
+    if of.op == "f32" then
+        local function write (b: buffer, pos: number, value: any): number
+            if type (value) ~= "number" then refuse (at, value) end
+
+            buffer.writef32 (b, pos, value)
+            return pos + bytes
+        end
+
+        local function read (b: buffer, pos: number, _ctx: Types.ValidateContext): (number, any)
+            return pos + bytes, buffer.readf32 (b, pos)
+        end
+
+        return write, read
+    end
+
+    local function write (b: buffer, pos: number, value: any): number
+        if type (value) ~= "number" then refuse (at, value) end
+
+        buffer.writef64 (b, pos, value)
+        return pos + bytes
+    end
+
+    local function read (b: buffer, pos: number, _ctx: Types.ValidateContext): (number, any)
+        return pos + bytes, buffer.readf64 (b, pos)
+    end
+
+    return write, read
+end
+
+-- One fixed field the run accumulator cannot pack, written as whole bytes of its own.
+function Leaf.wide (
+    of: Ir.Wide,
+    paths: Serial.Interner,
+    expected: Serial.Interner
+): (Ir.Write, Ir.Read)
+    local at = named (of.tag, paths, expected)
+    local grid = of.grid
+    local toIndex, fromIndex, span = grid.toIndex, grid.fromIndex, grid.span
+    local bytes = of.maxBytes
+    local ceiling = 2 ^ grid.width - 1
+
+    local function write (b: buffer, pos: number, value: any): number
+        local index = toIndex (value)
+        if index == nil then refuse (at, value) end
+
+        laid (b, pos, bytes, index :: number)
+        return pos + bytes
+    end
+
+    local function read (b: buffer, pos: number, _ctx: Types.ValidateContext): (number, any)
+        local index = taken (b, pos, bytes)
+        if index > ceiling then reject (Catalog.PAD, at, index) end
+        if index > span then reject (Catalog.TAG, at, index) end
+
+        return pos + bytes, fromIndex (index)
+    end
+
+    return write, read
+end
+
+-- A varint, through the one module that spells the groups.
+function Leaf.varint (
+    of: Ir.Varint,
+    paths: Serial.Interner,
+    expected: Serial.Interner
+): (Ir.Write, Ir.Read)
+    local at = named (of.tag, paths, expected)
+
+    -- Whole as well as within the ceiling, on both forms.
+    if of.op == "vlq" then
+        local function write (b: buffer, pos: number, value: any): number
+            if not (value >= 0 and value < EXACT and value % 1 == 0) then refuse (at, value) end
+            return Varint.write (b, pos, value)
+        end
+
+        local function read (b: buffer, pos: number, _ctx: Types.ValidateContext): (number, any)
+            local ok, value, after = pcall (Varint.read, b, pos)
+            if not ok then reject (Catalog.VARINT, at, value) end
+
+            return after :: number, value
+        end
+
+        return write, read
+    end
+
+    local function write (b: buffer, pos: number, value: any): number
+        if not (value > -EXACT and value < EXACT and value % 1 == 0) then refuse (at, value) end
+        return Varint.writeSigned (b, pos, value)
+    end
+
+    local function read (b: buffer, pos: number, _ctx: Types.ValidateContext): (number, any)
+        local ok, value, after = pcall (Varint.readSigned, b, pos)
+        if not ok then reject (Catalog.VARINT, at, value) end
+
+        return after :: number, value
+    end
+
+    return write, read
+end
+
+-- A string or a buffer, as its count and then its bytes.
+function Leaf.bytes (
+    of: Ir.Bytes,
+    paths: Serial.Interner,
+    expected: Serial.Interner
+): (Ir.Write, Ir.Read)
+    local at = named (of.tag, paths, expected)
+    local low, high = of.count.min, of.count.max
+    local span = high - low
+    local held = Bytes.whole (Bits.width (span))
+    local text = of.form == "string"
+
+    local alphabet = of.alphabet
+    if alphabet == nil then
+        local function write (b: buffer, pos: number, value: any): number
+            local count = if text then #value else buffer.len (value)
+            if count < low or count > high then refuse (at, count) end
+
+            laid (b, pos, held, count - low)
+            local after = pos + held
+
+            if text then
+                buffer.writestring (b, after, value)
+            else
+                buffer.copy (b, after, value)
+            end
+            return after + count
+        end
+
+        local function read (b: buffer, pos: number, _ctx: Types.ValidateContext): (number, any)
+            local index = taken (b, pos, held)
+            if index > span then reject (Catalog.COUNT, at, index) end
+
+            local count = index + low
+            local after = pos + held
+            if text then return after + count, buffer.readstring (b, after, count) end
+
+            local out = buffer.create (count)
+            buffer.copy (out, 0, b, after, count)
+            return after + count, out
+        end
+
+        return write, read
+    end
+
+    local width = Bits.width (#alphabet - 1)
+    local index: { [string]: number } = {}
+    local symbol: { string } = {}
+
+    for place = 1, #alphabet do
+        local one = string.sub (alphabet, place, place)
+        index[one] = place - 1
+        symbol[place] = one
+    end
+
+    local scratch: { number } = {}
+
+    local function write (b: buffer, pos: number, value: any): number
+        local count = #value
+        if count < low or count > high then refuse (at, count) end
+
+        for place = 1, count do
+            local one = index[string.sub (value, place, place)]
+            if one == nil then refuse (at, value) end
+            scratch[place] = one :: number
+        end
+
+        laid (b, pos, held, count - low)
+        return Leaf.packed (b, pos + held, width, count, scratch)
+    end
+
+    local function read (b: buffer, pos: number, _ctx: Types.ValidateContext): (number, any)
+        local counted = taken (b, pos, held)
+        if counted > span then reject (Catalog.COUNT, at, counted) end
+
+        local count = counted + low
+        local after, clean = Leaf.unpacked (b, pos + held, width, count, scratch)
+        if not clean then reject (Catalog.PAD, at, count) end
+
+        local out = table.create (count) :: { string }
+        for place = 1, count do
+            local one = symbol[scratch[place] + 1]
+            if one == nil then reject (Catalog.TAG, at, scratch[place]) end
+            out[place] = one :: string
+        end
+
+        return after, table.concat (out)
+    end
+
+    return write, read
+end
+
+-- Elements of one width, counted and then packed with nothing between them.
+function Leaf.run (
+    of: Ir.Run,
+    paths: Serial.Interner,
+    expected: Serial.Interner
+): (Ir.Write, Ir.Read)
+    local at = named (of.tag, paths, expected)
+    local low, high = of.count.min, of.count.max
+    local span = high - low
+    local held = Bytes.whole (Bits.width (span))
+
+    local elem = of.elem
+    local toIndex, fromIndex, reach = elem.toIndex, elem.fromIndex, elem.span
+    local width = elem.width
+
+    local scratch: { number } = {}
+
+    local function write (b: buffer, pos: number, value: any): number
+        local count = #value
+        if count < low or count > high then refuse (at, count) end
+
+        for place = 1, count do
+            local one = toIndex (value[place])
+            if one == nil then refuse (at, value[place]) end
+            scratch[place] = one :: number
+        end
+
+        laid (b, pos, held, count - low)
+        return Leaf.packed (b, pos + held, width, count, scratch)
+    end
+
+    local function read (b: buffer, pos: number, _ctx: Types.ValidateContext): (number, any)
+        local counted = taken (b, pos, held)
+        if counted > span then reject (Catalog.COUNT, at, counted) end
+
+        local count = counted + low
+        local after, clean = Leaf.unpacked (b, pos + held, width, count, scratch)
+        if not clean then reject (Catalog.PAD, at, count) end
+
+        local out = table.create (count) :: { any }
+        for place = 1, count do
+            local one = scratch[place]
+            if one > reach then reject (Catalog.TAG, at, one) end
+            out[place] = fromIndex (one)
+        end
+
+        return after, out
+    end
+
+    return write, read
+end
+
+-- An instance, as its slot in the array that rides beside the frame rather than in the bytes.
+function Leaf.slot (
+    of: Ir.Slot,
+    paths: Serial.Interner,
+    expected: Serial.Interner,
+    side: Ir.Sidecar
+): (Ir.Write, Ir.Read)
+    local at = named (of.tag, paths, expected)
+    local class = of.class
+
+    local refs, slotOf = side.refs, side.slotOf
+    side.bears = true
+
+    local function write (b: buffer, pos: number, value: any): number
+        if value == nil then return Varint.write (b, pos, NOTHING) end
+
+        local held = slotOf[value]
+        if held == nil then
+            held = #refs + 1
+            refs[held] = value
+            slotOf[value] = held
+        end
+
+        return Varint.write (b, pos, held :: number)
+    end
+
+    local function read (b: buffer, pos: number, _ctx: Types.ValidateContext): (number, any)
+        local ok, slot, after = pcall (Varint.read, b, pos)
+        if not ok then reject (Catalog.VARINT, at, slot) end
+
+        local one = refs[slot :: number]
+        if one == nil then return after :: number, nil end
+        if class ~= nil and not one:IsA (class) then reject (Catalog.SIDECAR, at, one.ClassName) end
+
+        return after :: number, one
+    end
+
+    return write, read
+end
+
+return table.freeze (Leaf)

package/shape/emit/Word.luau

@@ -0,0 +1,234 @@
+--!strict
+--!native
+--!optimize 2
+-- One bit region, as the pair of closures that lay it down and take it back up.
+
+local Catalog = require (script.Parent.Parent.Parent.kernel.Catalog)
+local Ir = require (script.Parent.Parent.Ir)
+local Log = require (script.Parent.Parent.Parent.kernel.Log)
+local Serial = require (script.Parent.Parent.Serial)
+local Words = require (script.Parent.Parent.Words)
+
+local Word = {}
+
+-- Constants -----------------------------------------------------------
+
+-- The same two widths a frame header reads, a region and a header being one kind of bit run.
+const ONE = Words.ONE
+const PAIR = Words.PAIR
+
+-- Types ---------------------------------------------------------------
+
+-- The two halves of a region, and the array of indices they meet in.
+export type Pack = (b: buffer, pos: number, value: any, slots: { number }, holds: { any }) -> ()
+export type Unpack = (b: buffer, pos: number, into: any, slots: { number }, holds: { any }) -> any
+
+-- Public --------------------------------------------------------------
+
+-- A value the schema has no place for, refused in the words a caller wrote.
+function Word.refused (path: string, wanted: string, got: any): never
+    return Log.refuse (
+        Log.line (Catalog.TAG, { path = path, expected = wanted, got = tostring (got) })
+    )
+end
+
+--[[
+    The same refusal from a tag, which is what a composite carries in place of the words.
+
+    A leaf holds its own and a composite holds the numbers they were interned under, so the lookup
+    is the half that differs and this is where the two meet.
+]]
+function Word.refusedAt (
+    tag: Ir.Tag,
+    paths: Serial.Interner,
+    said: Serial.Interner,
+    got: any
+): never
+    return Word.refused (paths.texts[tag.pathId], said.texts[tag.expectId], got)
+end
+
+-- The pair, with every constant the region is laid out by read once and held.
+function Word.emit (of: Ir.Word, paths: Serial.Interner, expected: Serial.Interner): (Pack, Unpack)
+    local leaves = of.leaves
+    local joins = of.joins
+    local held = #leaves
+
+    -- Per leaf, in wire order.
+    local spans = table.create (held, 0)
+    local toIndex = table.create (held) :: { (number) -> number? }
+    local fromIndex = table.create (held) :: { (number) -> number }
+
+    for index, grid in leaves do
+        spans[index] = grid.span
+        toIndex[index] = grid.toIndex
+        fromIndex[index] = grid.fromIndex
+    end
+
+    -- The leaves that occupy no bits, which is every grid holding one value.
+    local empties: { number } = {}
+    for index = 1, held do
+        if spans[index] == 0 then table.insert (empties, index) end
+    end
+
+    -- Per join, in the order the region reads its fields.
+    local reach = #joins
+    local starts = table.create (reach, 0)
+    local ends = table.create (reach, 0)
+    local keys = table.create (reach) :: { string? }
+    local inside = table.create (reach, 0)
+    local pulls = table.create (reach) :: { ((any, { number }, number) -> boolean)? }
+    local pushes = table.create (reach) :: { (({ number }, number) -> any)? }
+    local wheres = table.create (reach) :: { string }
+    local wanted = table.create (reach) :: { string }
+
+    for index, join in joins do
+        starts[index] = join.at
+        ends[index] = join.at + join.count - 1
+        keys[index] = join.key
+        inside[index] = join.nest or 0
+        pulls[index] = join.pull
+        pushes[index] = join.push
+        wheres[index] = paths.texts[join.tag.pathId]
+        wanted[index] = expected.texts[join.tag.expectId]
+    end
+
+    -- Per window, and then the parts of every window end to end.
+    local plan = of.plan
+    local windows = #plan
+    local width = table.create (windows, 0)
+    local where = table.create (windows, 0)
+    local first = table.create (windows, 0)
+    local last = table.create (windows, 0)
+
+    local slot: { number } = {}
+    local offset: { number } = {}
+    local span: { number } = {}
+    local shift: { number } = {}
+
+    for index, window in plan do
+        width[index] = window.bytes
+        where[index] = window.at
+        first[index] = #slot + 1
+
+        for _, part in window.parts do
+            table.insert (slot, part.field)
+            table.insert (offset, part.offset)
+            table.insert (span, part.width)
+            table.insert (shift, part.shift)
+        end
+
+        last[index] = #slot
+    end
+
+    --[[
+        Every field to its index, then every window to its bytes. In that order rather than one
+        pass, because a field can straddle two windows and a window can hold pieces of fields that
+        are nowhere near each other in the record.
+    ]]
+    local function pack (b: buffer, pos: number, value: any, slots: { number }, held: { any })
+        for index = 1, reach do
+            local key = keys[index]
+            local within = inside[index]
+            local from = if within == 0 then value else held[within]
+
+            local one = if key == nil then from else from[key]
+            local pull = pulls[index]
+
+            if pull == nil then
+                local at = starts[index]
+                local made = toIndex[at] (one)
+                if made == nil then Word.refused (wheres[index], wanted[index], one) end
+
+                slots[at] = made :: number
+                continue
+            end
+
+            if not pull (one, slots, starts[index]) then
+                Word.refused (wheres[index], wanted[index], one)
+            end
+        end
+
+        for index = 1, windows do
+            local acc = 0
+            for part = first[index], last[index] do
+                local piece = bit32.extract (slots[slot[part] ], shift[part], span[part])
+                acc = bit32.bor (acc, bit32.lshift (piece, offset[part]))
+            end
+
+            local at = pos + where[index]
+            local bytes = width[index]
+            if bytes == ONE then
+                buffer.writeu8 (b, at, acc)
+            elseif bytes == PAIR then
+                buffer.writeu16 (b, at, acc)
+            else
+                buffer.writeu32 (b, at, acc)
+            end
+        end
+    end
+
+    --[[
+        Every window to its pieces, then every field to its value. A piece at no shift is written
+        rather than merged, because what is under it is whatever the last call through this region
+        left there, and a field that straddles two windows meets its low piece first.
+    ]]
+    local function unpack (b: buffer, pos: number, into: any, slots: { number }, held: { any }): any
+        for _, leaf in empties do
+            slots[leaf] = 0
+        end
+
+        for index = 1, windows do
+            local at = pos + where[index]
+            local bytes = width[index]
+            local acc = if bytes == ONE
+                then buffer.readu8 (b, at)
+                elseif bytes == PAIR then buffer.readu16 (b, at)
+                else buffer.readu32 (b, at)
+
+            for part = first[index], last[index] do
+                local piece = bit32.extract (acc, offset[part], span[part])
+                local up = shift[part]
+                if up == 0 then
+                    slots[slot[part] ] = piece
+                    continue
+                end
+                slots[slot[part] ] = bit32.bor (slots[slot[part] ], bit32.lshift (piece, up))
+            end
+        end
+
+        local bare: any = nil
+
+        for index = 1, reach do
+            local join = joins[index]
+            for leaf = starts[index], ends[index] do
+                if slots[leaf] <= spans[leaf] then continue end
+                Log.reject (Catalog.TAG, {
+                    pathId = join.tag.pathId,
+                    expectId = join.tag.expectId,
+                    got = slots[leaf],
+                })
+            end
+
+            local push = pushes[index]
+            local one = if push == nil
+                then fromIndex[starts[index] ] (slots[starts[index] ])
+                else push (slots, starts[index])
+
+            local key = keys[index]
+            if key == nil then
+                bare = one
+                continue
+            end
+
+            local within = inside[index]
+            local up = if within == 0 then into else held[within]
+            up[key] = one
+        end
+
+        return bare
+    end
+
+    return pack, unpack
+end
+
+return table.freeze (Word)