@axpecter/lync 2.3.2 → 3.0.0

package/shape/emit/init.luau

@@ -0,0 +1,222 @@
+--!strict
+--!native
+--!optimize 2
+-- A shape and everything under it, as the one pair of closures the whole tree became.
+
+local Base = require (script.Parent.Parent.codec.Base)
+local Block = require (script.Block)
+local Catalog = require (script.Parent.Parent.kernel.Catalog)
+local Ir = require (script.Parent.Ir)
+local Leaf = require (script.Leaf)
+local Log = require (script.Parent.Parent.kernel.Log)
+local Serial = require (script.Parent.Serial)
+local Types = require (script.Parent.Parent.Types)
+local Word = require (script.Word)
+
+local Emit = {}
+
+-- Constants -----------------------------------------------------------
+
+-- Types ---------------------------------------------------------------
+
+-- Everything a walk needs that is not the node it is on.
+export type Site = {
+    read paths: Serial.Interner,
+    read expected: Serial.Interner,
+    read sidecar: Ir.Sidecar,
+}
+
+-- State ---------------------------------------------------------------
+
+-- The first reason a check gave while one payload was decoding, held until that payload is done.
+local parkedPath: number? = nil
+local parkedReason: string? = nil
+
+-- Private -------------------------------------------------------------
+
+-- Every check a place declared, in the order they were declared, and the first reason one gives.
+local function turned (tag: Ir.Tag, value: any, ctx: Types.ValidateContext)
+    local checks = tag.checks :: { Base.Validate }
+
+    for index = 1, #checks do
+        local why = checks[index] (value, ctx)
+        if why == nil then continue end
+
+        if parkedPath == nil then
+            parkedPath = tag.pathId
+            parkedReason = why
+        end
+        return
+    end
+end
+
+-- A node's own checks, wrapped round the read once here so a node without any pays for nothing.
+local function checked (read: Ir.Read, tag: Ir.Tag): Ir.Read
+    return function (b: buffer, pos: number, ctx: Types.ValidateContext): (number, any)
+        local at, value = read (b, pos, ctx)
+        turned (tag, value, ctx)
+        return at, value
+    end
+end
+
+-- Where a region's field sits in the record the group answers, as the names to walk to reach it.
+local function chained (of: Ir.Group, join: Ir.Join): { string }
+    local key = join.key
+    local out: { string } = if key == nil then {} else { key }
+
+    local at = join.nest
+    while at ~= nil do
+        local nest = of.nests[at]
+        table.insert (out, 1, nest.key)
+        at = nest.under
+    end
+    return out
+end
+
+-- The checks of a region's fields, wrapped round the group that holds the region.
+local function fielded (read: Ir.Read, of: Ir.Group): Ir.Read
+    local word = of.word
+    if word == nil then return read end
+
+    local looks: { Ir.Join } = {}
+    local within: { { string } } = {}
+
+    for _, join in word.joins do
+        if join.tag.checks == nil then continue end
+
+        table.insert (looks, join)
+        table.insert (within, chained (of, join))
+    end
+
+    local reach = #looks
+    if reach == 0 then return read end
+
+    return function (b: buffer, pos: number, ctx: Types.ValidateContext): (number, any)
+        local at, value = read (b, pos, ctx)
+
+        for index = 1, reach do
+            local one = value
+            for _, name in within[index] do
+                one = one[name]
+            end
+
+            turned (looks[index].tag, one, ctx)
+        end
+
+        return at, value
+    end
+end
+
+-- One node to its pair, with its children already theirs.
+local function made (of: Ir.Shape, at: Site): (Ir.Write, Ir.Read)
+    local paths, expected = at.paths, at.expected
+
+    --[[
+        A region alone is a record with no fields after it. It has joins and so it has a value, but
+        the pair that lays a region down fills an array rather than answering, and the thing that
+        turns that into a value is the group. So a bare one is emitted as the group it means.
+    ]]
+    if of.op == "word" then return made (Ir.group (of.tag, of, {}), at) end
+
+    if of.op == "wide" then return Leaf.wide (of, paths, expected) end
+    if of.op == "f32" or of.op == "f64" then return Leaf.float (of, paths, expected) end
+    if of.op == "vlq" or of.op == "vli" then return Leaf.varint (of, paths, expected) end
+    if of.op == "bytes" then return Leaf.bytes (of, paths, expected) end
+    if of.op == "run" then return Leaf.run (of, paths, expected) end
+
+    if of.op == "group" then
+        local word = of.word
+        local pack: Word.Pack?, unpack: Word.Unpack?
+        if word ~= nil then
+            pack, unpack = Word.emit (word, paths, expected)
+        end
+
+        local reach = #of.parts
+        local writes = table.create (reach) :: { Ir.Write }
+        local reads = table.create (reach) :: { Ir.Read }
+
+        for index, part in of.parts do
+            writes[index], reads[index] = Emit.emit (part.of, at)
+        end
+
+        local write, read = Block.group (of, pack, unpack, writes, reads, paths, expected)
+        return write, fielded (read, of)
+    end
+
+    if of.op == "apart" then
+        local reach = #of.parts
+        local writes = table.create (reach) :: { Ir.Write }
+        local reads = table.create (reach) :: { Ir.Read }
+
+        for index, part in of.parts do
+            writes[index], reads[index] = Emit.emit (part, at)
+        end
+
+        return Block.apart (of, writes, reads, paths, expected)
+    end
+
+    if of.op == "list" then
+        local write, read = Emit.emit (of.elem, at)
+        return Block.list (of, write, read, paths, expected)
+    end
+
+    if of.op == "pairs" then
+        local writeKey, readKey = Emit.emit (of.key, at)
+        local writeValue, readValue = Emit.emit (of.value, at)
+
+        return Block.pairs (of, writeKey, readKey, writeValue, readValue, paths, expected)
+    end
+
+    --[[
+        An optional is its own value and a bit of the region beside it, and the bit is the group's.
+        So there is no closure here that a present field does not already have, and an absent one is
+        a call the group does not make.
+    ]]
+    if of.op == "opt" then return Emit.emit (of.inner, at) end
+
+    if of.op == "branch" then
+        local reach = #of.arms
+        local writes = table.create (reach) :: { Ir.Write }
+        local reads = table.create (reach) :: { Ir.Read }
+
+        for index, arm in of.arms do
+            writes[index], reads[index] = Emit.emit (arm, at)
+        end
+
+        return Block.branch (of, writes, reads, paths, expected)
+    end
+
+    if of.op == "xform" then
+        local write, read = Emit.emit (of.inner, at)
+        return Block.xform (of, write, read)
+    end
+
+    return Leaf.slot (of, paths, expected, at.sidecar)
+end
+
+-- Public --------------------------------------------------------------
+
+-- A shape and everything under it, as the pair the whole tree became.
+function Emit.emit (of: Ir.Shape, at: Site): (Ir.Write, Ir.Read)
+    local write, read = made (of, at)
+    local held = if of.tag.checks == nil then read else checked (read, of.tag)
+
+    -- The root, which is the one place a parked reason becomes a refusal.
+    local function taken (b: buffer, pos: number, ctx: Types.ValidateContext): (number, any)
+        parkedPath = nil
+        parkedReason = nil
+
+        local ends, value = held (b, pos, ctx)
+        if parkedPath == nil then return ends, value end
+
+        local path, reason = parkedPath, parkedReason
+        parkedPath = nil
+        parkedReason = nil
+
+        return Log.reject (Catalog.VALIDATE, { pathId = path, reason = reason, at = ends })
+    end
+
+    return write, taken
+end
+
+return table.freeze (Emit)

package/shape/init.luau

@@ -0,0 +1,78 @@
+--!strict
+--!optimize 2
+-- One declaration to the pair that writes it and reads it back, which is the whole compile path.
+
+local Base = require (script.Parent.codec.Base)
+local Emit = require (script.emit)
+local Grid = require (script.Grid)
+local Ir = require (script.Ir)
+local Lower = require (script.Lower)
+local Serial = require (script.Serial)
+local Types = require (script.Parent.Types)
+
+local Shape = {}
+
+-- Types ---------------------------------------------------------------
+
+-- What a build interns and what it hands a sidecar, declared below and passed on unchanged.
+export type Site = Emit.Site
+
+-- A declaration compiled: the pair, what it costs, and the facts everything above reads off it.
+export type Built = {
+    read cell: Base.Cell,
+    read write: Ir.Write,
+    read read: Ir.Read,
+    read maxBytes: number,
+    read fixed: boolean,
+    read tag: Ir.Tag,
+    read grid: Grid.Grid?,
+    read marker: Base.Marker,
+    read sidecar: Ir.Sidecar,
+    read paths: Serial.Interner,
+    read expected: Serial.Interner,
+}
+
+-- Private -------------------------------------------------------------
+
+-- The grid a whole declaration is one index on, where it is one, and nothing where it is not.
+local function gridded (of: Ir.Shape): Grid.Grid?
+    if of.op == "xform" then return gridded (of.inner) end
+    if of.op == "wide" then return of.grid end
+    if of.op ~= "word" then return nil end
+
+    -- A pull spreads one value over several leaves, so there is no single index to answer with.
+    if of.joins[1].pull ~= nil then return nil end
+    return of.leaves[1]
+end
+
+-- Public --------------------------------------------------------------
+
+-- A codec and where a refusal inside it says it is, as the build everything above holds.
+function Shape.build (of: Types.Codec<any>, at: string, shared: Site?): Built
+    local cell = Base.cell (of)
+    local site: Site = shared
+        or {
+            paths = Serial.interner (),
+            expected = Serial.interner (),
+            sidecar = { refs = {}, slotOf = {}, bears = false },
+        }
+
+    local shape = Lower.of (cell, at, site)
+    local write, read = Emit.emit (shape, site)
+
+    return table.freeze ({
+        cell = cell,
+        write = write,
+        read = read,
+        maxBytes = shape.maxBytes,
+        fixed = shape.fixed,
+        tag = shape.tag,
+        grid = gridded (shape),
+        marker = cell.marker,
+        sidecar = site.sidecar,
+        paths = site.paths,
+        expected = site.expected,
+    })
+end
+
+return table.freeze (Shape)

package/state/Apply.luau

@@ -0,0 +1,330 @@
+--!strict
+--!optimize 2
+-- The one path a section becomes a store by, which both machines run over the same sections.
+
+local Protocol = require (script.Parent.Parent.wire.Protocol)
+local Sections = require (script.Parent.Sections)
+local Store = require (script.Parent.Store)
+local Types = require (script.Parent.Parent.Types)
+
+local Apply = {}
+
+-- Constants -----------------------------------------------------------
+
+const KEYFRAME = Protocol.SECTION_KEYFRAME
+const DELTA = Protocol.SECTION_DELTA
+const REMOVAL = Protocol.SECTION_REMOVAL
+
+-- The two causes a section can be read as, which is every cause there is.
+const REMOVED: Types.Cause = "removed"
+const CLEARED: Types.Cause = "cleared"
+
+-- What a frame came to for one record, which is everything a caller can be told about one.
+const NOTHING = 0
+const ARRIVED = NOTHING + 1
+const CHANGED = ARRIVED + 1
+const GONE = CHANGED + 1
+const REPLACED = GONE + 1
+
+-- Types ---------------------------------------------------------------
+
+--[[
+    What a frame did to one set, held per set rather than per partition because an id is unique
+    across the set and a slot is not. `net` is what the frame came to for each record and the whole
+    of what a caller is told, `added`, `changed` and `gone` are that taken apart for the fan, `olds`
+    is the record as it stood, and `shadow` is the slots a keyframe spoke for.
+]]
+export type Heard = {
+    watching: boolean,
+    net: { [number]: number },
+    left: { [number]: Store.Store },
+    added: { number },
+    changed: { number },
+    gone: { number },
+    causes: { [number]: Types.Cause },
+    olds: { [number]: Store.Record },
+    shadow: { [Store.Store]: { [number]: boolean } },
+    owed: number,
+    holds: { { [number]: number } },
+    where: { number },
+    marks: { number },
+}
+
+-- Private -------------------------------------------------------------
+
+-- What a partition's keyframes have spoken for this frame, made where the first one is applied.
+local function shadowed (of: Heard, store: Store.Store): { [number]: boolean }
+    local held = of.shadow[store]
+    if held ~= nil then return held end
+
+    local made: { [number]: boolean } = {}
+    of.shadow[store] = made
+    return made
+end
+
+-- A baseline a keyframe stated, kept until every section of the frame has been read.
+local function owes (of: Heard, held: { [number]: number }, slot: number, mark: number)
+    local at = of.owed + 1
+
+    of.owed = at
+    of.holds[at] = held
+    of.where[at] = slot
+    of.marks[at] = mark
+end
+
+-- Whether the record as it stood before this frame is worth keeping at all.
+local function kept (of: Heard, id: number): boolean return of.watching and of.olds[id] == nil end
+
+-- The record as it stood, kept where it lies, because this one is on its way out.
+local function shed (of: Heard, store: Store.Store, id: number)
+    if not kept (of, id) then return end
+
+    local row = store.rows[id]
+    if row == nil then return end
+
+    of.olds[id] = row
+end
+
+-- The record as it stood before this frame, taken once and only where something wants it.
+local function snapped (of: Heard, store: Store.Store, id: number)
+    if not kept (of, id) then return end
+
+    local row = store.rows[id]
+    if row == nil then return end
+
+    of.olds[id] = table.clone (row)
+end
+
+-- The same, for the lane that does not come through a section.
+function Apply.snapped (of: Heard, store: Store.Store, id: number) snapped (of, store, id) end
+
+-- A record established, which is an arrival unless this frame has already taken it away.
+local function born (of: Heard, store: Store.Store, id: number)
+    local was = of.net[id]
+
+    if was == GONE then
+        of.net[id] = if of.left[id] == store then REPLACED else CHANGED
+        return
+    end
+    if was == CHANGED or was == REPLACED then return end
+
+    of.net[id] = ARRIVED
+end
+
+local function moved (of: Heard, id: number) Apply.moved (of, id) end
+
+-- A record taken away, which cancels an arrival rather than following it.
+local function lost (of: Heard, store: Store.Store, id: number, why: Types.Cause)
+    if of.net[id] == ARRIVED then
+        of.net[id] = NOTHING
+        return
+    end
+
+    of.net[id] = GONE
+    of.left[id] = store
+    of.causes[id] = why
+end
+
+--[[
+    A partition emptied, and every record it held reported gone.
+
+    Read before the store is emptied rather than after, which is the only order there is: what a
+    clear says is every record this receiver held, and afterwards it holds none.
+]]
+local function emptied (store: Store.Store, of: Heard)
+    for id in store.rows do
+        shed (of, store, id)
+        lost (of, store, id, CLEARED)
+    end
+
+    Store.clear (store)
+end
+
+--[[
+    The listed records gone. A slot this receiver does not hold is a specified no-op rather than a
+    fault, since a removal is broadcast and an audience is what decides who was holding one.
+]]
+local function dropped (store: Store.Store, frame: Sections.Frame, of: Heard)
+    for index = 1, frame.count do
+        local id = store.ids[frame.slots[index] ]
+        if id == nil then continue end
+
+        shed (of, store, id)
+        Store.unbind (store, id)
+        lost (of, store, id, REMOVED)
+    end
+end
+
+--[[
+    The listed records established: bound to the slots the other machine chose, at the generations
+    it stated, with every field of every one of them written whole.
+]]
+local function established (store: Store.Store, layout: Sections.Layout, of: Heard)
+    local frame = layout.frame
+    local shadow = shadowed (of, store)
+    local gens = store.gens
+
+    for index = 1, frame.count do
+        local slot = frame.slots[index]
+        local id = frame.ids[index]
+        local was = store.slotOf[id]
+
+        snapped (of, store, id)
+        Store.hold (store, id, slot)
+        if gens ~= nil then gens[slot] = frame.gens[index] end
+
+        shadow[slot] = true
+        if was == nil then
+            born (of, store, id)
+        else
+            moved (of, id)
+        end
+    end
+
+    for field = 1, layout.def.fieldCount do
+        local values = frame.values[field]
+        local marks = frame.at[field]
+        local held = store.prev[field]
+
+        for index = 1, frame.count do
+            local slot = frame.slots[index]
+
+            Store.write (store, slot, field, values[index])
+            if held ~= nil then owes (of, held, slot, marks[index]) end
+        end
+    end
+end
+
+--[[
+    The listed differences applied, for the slots this receiver holds and this frame has not already
+    spoken for.
+]]
+local function advanced (store: Store.Store, layout: Sections.Layout, of: Heard)
+    local frame = layout.frame
+    local chosen = frame.chosen
+    local shadow = shadowed (of, store)
+    local ids = store.ids
+
+    for place = 1, chosen.count do
+        local field = chosen.fields[place]
+        local under = frame.under[place]
+        local values = frame.values[field]
+        local marks = frame.at[field]
+        local held = store.prev[field]
+
+        for index = 1, frame.covered[place] do
+            local slot = under[index]
+            local id = ids[slot]
+            if id == nil or shadow[slot] then continue end
+
+            local before = store.columns[field][slot]
+
+            snapped (of, store, id)
+            Store.write (store, slot, field, values[index])
+            if held ~= nil then held[slot] = marks[index] end
+
+            -- A value that arrived as what the field already held is no change to report.
+            if before ~= values[index] then moved (of, id) end
+        end
+    end
+end
+
+-- Public --------------------------------------------------------------
+
+-- One record changed, said once however many times a frame says it.
+function Apply.moved (of: Heard, id: number)
+    local was = of.net[id]
+    if was == ARRIVED or was == REPLACED then return end
+
+    of.net[id] = CHANGED
+end
+
+-- What the frame came to, as the three lists the fan reads, each in id order.
+function Apply.parted (of: Heard): ({ number }, { number }, { number })
+    local gone, added, changed = of.gone, of.added, of.changed
+
+    table.clear (gone)
+    table.clear (added)
+    table.clear (changed)
+
+    for id, net in of.net do
+        if net == GONE or net == REPLACED then table.insert (gone, id) end
+        if net == ARRIVED or net == REPLACED then table.insert (added, id) end
+        if net == CHANGED then table.insert (changed, id) end
+    end
+
+    table.sort (gone)
+    table.sort (added)
+    table.sort (changed)
+
+    return gone, added, changed
+end
+
+-- What a frame did to one set, empty, which a set holds one of for as long as it exists.
+function Apply.heard (): Heard
+    return {
+        watching = false,
+        net = {},
+        left = {},
+        added = {},
+        changed = {},
+        gone = {},
+        causes = {},
+        olds = {},
+        shadow = {},
+        owed = 0,
+        holds = {},
+        where = {},
+        marks = {},
+    }
+end
+
+-- One section, into the partition it is about.
+function Apply.section (store: Store.Store, layout: Sections.Layout, kind: number, of: Heard)
+    if kind == KEYFRAME then
+        established (store, layout, of)
+        return
+    end
+
+    if kind == DELTA then
+        advanced (store, layout, of)
+        return
+    end
+
+    if kind == REMOVAL then
+        dropped (store, layout.frame, of)
+        return
+    end
+
+    emptied (store, of)
+end
+
+-- The frame over: what its keyframes owe, paid, and what they spoke for, forgotten.
+function Apply.settle (of: Heard)
+    for index = 1, of.owed do
+        of.holds[index][of.where[index] ] = of.marks[index]
+    end
+    of.owed = 0
+
+    for _, held in of.shadow do
+        table.clear (held)
+    end
+end
+
+--[[
+    What the frame did, forgotten, which is what a caller does once it has said so.
+
+    Apart from the settling because the two answer to different things: the baselines are owed to
+    the next frame and cannot wait on anybody, and this waits on every listener having run.
+]]
+function Apply.forget (of: Heard)
+    table.clear (of.net)
+    table.clear (of.left)
+    table.clear (of.added)
+    table.clear (of.changed)
+    table.clear (of.gone)
+    table.clear (of.causes)
+    table.clear (of.olds)
+end
+
+return table.freeze (Apply)