honey/source/sema/check/check.hon

import "@std/debug"
import "@std/mem"
import "@std/arraylist"
import "@std/hashmap"
import "@std/strconv"
import "@source/ast"
import "@source/diagnostics"
sema :: import "@source/sema"

TypeKind :: enum {
    none
    invalid
    int
    float
    bool
    string
    void
    function
    range
    array
    pointer
    record
    enumeration
    type_value
    u8, u16, u32, u64, usize
    i8, i16, i32, isize
    slice
    optional
    null
    anyopaque
    fallible
}

RecordId :: distinct u32
no_record :: maxval!(RecordId)

EnumId :: distinct u32
no_enum :: maxval!(EnumId)

EnumMember :: struct {
    name ast.NodeId
    magnitude u64
    negative bool = false
}

EnumType :: struct {
    declaration ast.NodeId
    backing TypeKind
    explicit_backing bool = false
    members []EnumMember
    composed bool = false
}

RecordField :: struct {
    name ?ast.NodeId
    type Type
    default ?ast.NodeId
}

RecordType :: struct {
    declaration ast.NodeId
    fields []RecordField
    is_union bool = false
    tag_type Type = Type{}
    declared_tag_type Type = Type{}
    composed bool = false
}

@hide:file
RecordInitializer :: struct {
    fields []mut ast.NodeId
}

ArrayId :: distinct u32
no_array :: maxval!(ArrayId)

ArrayType :: struct {
    element Type
    len usize = 0
    mutable bool = false
    kind TypeKind = .array
    sentinel ?i64 = null
    error_type Type = Type{}
}

PointerId :: distinct u32
no_pointer :: maxval!(PointerId)

PointerType :: struct {
    element Type
    mutable bool
    many bool
}

Type :: struct {
    kind TypeKind = .none
    function ast.NodeId = ast.NodeId(maxval!(u32))
    diagnostic diagnostics.DiagnosticId = diagnostics.no_diagnostic
    array_type ArrayId = no_array
    pointer_type PointerId = no_pointer
    range_element TypeKind = .none
    record_type RecordId = no_record
    enum_type EnumId = no_enum
    nominal ast.NodeId = ast.NodeId(maxval!(u32))
    value_kind TypeKind = .none
}

@hide:file
Storage :: struct {
    tree @ast.Tree
    types []mut Type
    arrays arraylist.ArrayList(ArrayType)
    pointers arraylist.ArrayList(PointerType)
    records arraylist.ArrayList(RecordType)
    enums arraylist.ArrayList(EnumType)
    backings []mut Type
    exhaustive []mut bool
    variant_slots []mut usize
    initializers arraylist.ArrayList(RecordInitializer)
    slots []mut usize
    fallthroughs hashmap.AutoHashMap(ast.NodeId, diagnostics.DiagnosticId)
    allocator mem.Allocator
}

#! owns node-indexed types, aggregate descriptors, initializer mappings, and function fallthrough obligations; release with deinit.
#! borrows the caller-owned AST for signature comparisons; diagnostic IDs refer to the caller-owned store.
Result :: struct { storage Storage }

@hide:file
no_index :: maxval!(usize)

@hide:file
Role :: enum {
    none,
    expression,
    declaration,
    parameter,
    function,
    annotation,
    invalid,
    body,
    return_stmt,
    if_stmt,
    assignment_stmt,
    while_stmt,
    for_stmt,
    loop_capture,
    loop_control,
    cleanup,
}

@hide:file
GroupLink :: struct {
    parent usize = 0
    size usize = 1
}

@hide:file
Cell :: struct {
    role Role = .none
    type Type = Type{}
    numeric bool = false
    anchored bool = false
    demand TypeKind = .none
    conversion_unsigned bool = false
    fixed bool = false
    local bool = false
    assignment_value bool = false
    for_iterable bool = false
    expected Type = Type{}
    visiting bool = false
    constant_visiting bool = false
    count_declaration bool = false
    literal ast.NodeId = ast.NodeId(maxval!(u32))
    producer ast.NodeId = ast.NodeId(maxval!(u32))
    capture ast.NodeId = ast.NodeId(maxval!(u32))
    record_checking bool = false
    record_pointer_depth usize = 0
    nominal bool = false
    match_pattern bool = false
    first_edge usize = no_index
    return_annotation ast.NodeId = ast.NodeId(maxval!(u32))
    in_cleanup bool = false
    narrowing_arm ast.NodeId = ast.NodeId(maxval!(u32))
    enclosing_arm ast.NodeId = ast.NodeId(maxval!(u32))
    match_owner ast.NodeId = ast.NodeId(maxval!(u32))
    narrowed_type Type = Type{}
}

@hide:file
Edge :: struct {
    dependent ast.NodeId
    next usize
}

@hide:file
Variant :: struct {
    name ast.NodeId
    payload Type
}

@hide:file
State :: struct {
    tree @ast.Tree
    resolution @sema.Resolution
    diagnostics @mut diagnostics.Store
    types []mut Type
    cells []mut Cell
    groups []mut GroupLink
    edges arraylist.ArrayList(Edge)
    arrays arraylist.ArrayList(ArrayType)
    pointers arraylist.ArrayList(PointerType)
    records arraylist.ArrayList(RecordType)
    initializers arraylist.ArrayList(RecordInitializer)
    enums arraylist.ArrayList(EnumType)
    variants arraylist.ArrayList(Variant)
    backings []mut Type
    exhaustive []mut bool
    variant_slots []mut usize
    return_annotation ast.NodeId = ast.NodeId(maxval!(u32))
    in_loop bool = false
    in_cleanup bool = false
    narrowing_arm ast.NodeId = ast.NodeId(maxval!(u32))
    slots []mut usize
    collecting_assignment bool = false
    has_assignments bool = false
    pointer_depth usize = 0
}

#! borrows resolution and diagnostics during checking; Result retains the AST borrow for signature comparisons.
#! temporary constraints are freed on every exit; Result owns types, aggregate descriptors, initializer mappings, and fallthrough obligations.
check proc(
    allocator mem.Allocator,
    tree @ast.Tree,
    resolution @sema.Resolution,
    diagnostic_store @mut diagnostics.Store,
) Result ! (mem.AllocError | diagnostics.CapacityError) {
    return try check_elaborated(allocator, tree, resolution, &[], diagnostic_store)
}

#! checks additional compile-time expressions retained when elaboration erased their calls.
check_elaborated proc(
    allocator mem.Allocator,
    tree @ast.Tree,
    resolution @sema.Resolution,
    constraints []ast.NodeId,
    diagnostic_store @mut diagnostics.Store,
) Result ! (mem.AllocError | diagnostics.CapacityError) {
    count :: ast.node_count(tree)
    types :: try mem.alloc(Type, allocator, count)
    errdefer mem.free(allocator, types)
    mem.set(types, Type{})
    cells :: try mem.alloc(Cell, allocator, count)
    defer mem.free(allocator, cells)
    mem.set(cells, Cell{})
    groups :: try mem.alloc(GroupLink, allocator, count)
    defer mem.free(allocator, groups)
    mem.set(groups, GroupLink{})
    for (0..count) |i| groups[i].parent = i
    queue :: try mem.alloc(ast.NodeId, allocator, count)
    defer mem.free(allocator, queue)
    slots :: try mem.alloc(usize, allocator, count)
    errdefer mem.free(allocator, slots)
    mem.set(slots, no_index)
    backings :: try mem.alloc(Type, allocator, count)
    errdefer mem.free(allocator, backings)
    mem.set(backings, Type{})
    exhaustive :: try mem.alloc(bool, allocator, count)
    errdefer mem.free(allocator, exhaustive)
    mem.set(exhaustive, false)
    variant_slots :: try mem.alloc(usize, allocator, count)
    errdefer mem.free(allocator, variant_slots)
    mem.set(variant_slots, no_index)
    state := State{
        tree = tree,
        resolution = resolution,
        diagnostics = diagnostic_store,
        types = types,
        cells = cells,
        groups = groups,
        edges = arraylist.init(allocator),
        arrays = arraylist.init(allocator),
        pointers = arraylist.init(allocator),
        records = arraylist.init(allocator),
        initializers = arraylist.init(allocator),
        slots = slots,
        enums = arraylist.init(allocator),
        backings = backings,
        exhaustive = exhaustive,
        variant_slots = variant_slots,
        variants = arraylist.init(allocator),
    }
    defer arraylist.deinit(&state.edges)
    defer arraylist.deinit(&state.variants)
    errdefer arraylist.deinit(&state.arrays)
    errdefer arraylist.deinit(&state.pointers)
    errdefer {
        for (state.enums.items) |descriptor| mem.free(allocator, descriptor.members)
        arraylist.deinit(&state.enums)
        for (state.records.items) |record| mem.free(allocator, record.fields)
        arraylist.deinit(&state.records)
        for (state.initializers.items) |initializer| mem.free(allocator, initializer.fields)
        arraylist.deinit(&state.initializers)
    }

    for 0..ast.package_decl_count(tree) |i| {
        id :: ast.package_decl(tree, i)
        if (ast.decl_kind(tree, id) == .statement) cells[usize(id)].count_declaration = true
    }
    for (0..ast.package_decl_count(tree)) |i| {
        id :: ast.package_decl(tree, i)
        match ast.decl_kind(tree, id) {
            .statement: try collect_declaration(&state, id)
            .function: try collect_function(&state, id)
            .invalid: collect_invalid(&state, id)
            .import: {}
        }
    }
    for (constraints) |constraint| {
        if (ast.node_class(tree, constraint) == .statement) {
            state.cells[usize(constraint)].local = true
            try collect_declaration(&state, constraint)
        } else try collect_expression(&state, constraint)
    }
    # Preserve binding errors before RHS errors propagate. Indexed writability
    # waits for shapes; neither check poisons the target's type.
    for 0..count |i| {
        if (cells[i].role != .assignment_stmt) continue
        target :: ast.assignment_stmt(tree, ast.NodeId(i)).target
        if (!declaration_reference(tree, target)) continue
        binding :: sema.binding(resolution, target)
        if (binding.kind == .invalid) {
            cells[i].type = invalid_type(binding.data.diagnostic)
        } else if (binding.kind == .declaration and !mutable_target(&state, target, false)) {
            cells[i].type = invalid_type(try diagnostics.add(
                diagnostic_store, .invalid_assignment_target, ast.node_span(tree, target),
            ))
        }
    }

    # aliases share a type variable; explicit annotations and parameters are boundaries.
    for (0..count) |i| {
        id :: ast.NodeId(i)
        if (cells[i].role != .expression or !declaration_reference(tree, id)) continue
        if (cells[i].type.kind == .invalid) continue
        binding :: sema.binding(resolution, id)
        if (binding.kind != .declaration) continue
        target :: binding.data.declaration
        try depend(&state, target, id)
        if (cells[usize(target)].fixed) cells[i].type = cells[usize(target)].type
    }
    for (0..count) |i| {
        id :: ast.NodeId(i)
        if (cells[i].role == .declaration and !cells[i].fixed) {
            join(&state, id, ast.statement_decl(tree, id).initializer)
        }
        if (cells[i].role != .expression or !declaration_reference(tree, id)) continue
        if (cells[i].type.kind == .invalid) continue
        binding :: sema.binding(resolution, id)
        if (binding.kind == .declaration and !cells[i].assignment_value
            and !cells[usize(binding.data.declaration)].fixed and !has_narrowing(&state, id)) {
            join(&state, id, binding.data.declaration)
        }
    }

    # assignment inputs observe established declaration types, never contribute
    # constraints back into those declarations.
    for 0..2 |phase| {
        if (phase == 1 and !state.has_assignments) break
        assignment_values :: phase == 1
        if (assignment_values) {
            for (0..count) |i| {
                id :: ast.NodeId(i)
                if (!cells[i].assignment_value
                    or cells[i].role != .expression
                    or !declaration_reference(tree, id)
                ) continue
                if (cells[i].type.kind == .invalid) continue
                binding :: sema.binding(resolution, id)
                if (binding.kind == .declaration) cells[i].type = types[usize(binding.data.declaration)]
            }
        }
        # Calls use the signature result before contextual literal inference.
        try prepare_optional_captures(&state, false)
        for (0..count) |i| {
            id :: ast.NodeId(i)
            if (cells[i].role != .expression or cells[i].assignment_value != assignment_values or ast.expr_kind(tree, id) != .call) continue
            if (conversion_kind(&state, id) != .none or state.backings[i].kind != .none) continue
            callee :: ast.call_expr(tree, id).callee
            signature :: try infer_shape(&state, callee, false)
            if (signature.function != ast.NodeId(maxval!(u32))) {
                result :: ast.callable_result(tree, signature.function)
                seed(&state, id, types[usize(result)])
            } else if (signature.kind == .invalid) {
                seed(&state, id, signature)
            }
        }
        for (0..count) |i| {
            id :: ast.NodeId(i)
            if (cells[i].role != .expression or cells[i].assignment_value != assignment_values or ast.expr_kind(tree, id) != .call) continue
            if (conversion_kind(&state, id) != .none or state.backings[i].kind != .none) continue
            callee :: ast.call_expr(tree, id).callee
            signature :: group_type(&state, callee)
            if (signature.function != ast.NodeId(maxval!(u32))) continue
            if (signature.kind == .invalid) {
                seed(&state, id, signature)
            } else if (signature.kind != .none or cells[root(&state, usize(callee))].numeric) {
                seed(&state, id, invalid_type(try diagnostics.add(diagnostic_store, .not_callable, ast.node_span(tree, callee))))
            } else {
                # without a function anchor, share the eventual inference error.
                join(&state, id, callee)
            }
        }
        for (0..count) |i| {
            if (cells[i].role == .none or cells[i].role == .body or cells[i].assignment_value != assignment_values or types[i].kind == .invalid) continue
            types[i] = cells[root(&state, i)].type
        }
        # reject nonnumeric operations before connecting otherwise valid inputs.
        try apply_contexts(&state, assignment_values, true)
        try prepare_shapes(&state, assignment_values, false)
        try prepare_ranges(&state, assignment_values, false)
        for (0..count) |i| {
            id :: ast.NodeId(i)
            if (cells[i].role != .expression or cells[i].assignment_value != assignment_values) continue
            match ast.expr_kind(tree, id) {
                .unary: {
                    expression :: ast.unary_expr(tree, id)
                    if (expression.operator == .negate) try require_numeric(&state, id, expression.operand)
                }
                .binary: {
                    expression :: ast.binary_expr(tree, id)
                    if (logical(expression.operator) or bool_equality(&state, id) or pointer_addition(&state, id)) continue
                    try require_numeric(&state, id, expression.left)
                    try require_numeric(&state, id, expression.right)
                }
                else: {}
            }
        }
        propagate(&state, queue)

        # numeric edges join flexible operands; rigid inputs supply only demands.
        for (0..count) |i| {
            id :: ast.NodeId(i)
            if (cells[i].role != .expression or cells[i].assignment_value != assignment_values) continue
            match ast.expr_kind(tree, id) {
                .unary: {
                    expression :: ast.unary_expr(tree, id)
                    if (expression.operator == .negate) try numeric_operand(&state, id, expression.operand)
                }
                .binary: {
                    expression :: ast.binary_expr(tree, id)
                    if (logical(expression.operator) or pointer_addition(&state, id)) continue
                    if (comparison(expression.operator)) {
                        if (!bool_equality(&state, id)) try comparison_operands(&state, id)
                    } else {
                        try numeric_operand(&state, id, expression.left)
                        try numeric_operand(&state, id, expression.right)
                        if (expression.operator == .divide) {
                            try impose(&state, id, .float, .integer_division, expression.span)
                        }
                    }
                }
                else: {}
            }
        }
        try apply_contexts(&state, assignment_values, false)
        try prepare_shapes(&state, assignment_values, false)
        try prepare_ranges(&state, assignment_values, true)
        for 0..count |i| {
            id :: ast.NodeId(i)
            if (cells[i].role != .expression or cells[i].assignment_value != assignment_values or ast.expr_kind(tree, id) != .index) continue
            try demand(&state, ast.index_expr(tree, id).index, Type{ kind = .usize }, .invalid_index_type)
        }

        # defaults follow ordinary program demands, then isolated assignment demands.
        for (0..count) |i| {
            if (root(&state, i) != i or cells[i].assignment_value != assignment_values) continue
            if (cells[i].type.kind == .invalid) continue
            if (cells[i].numeric and cells[i].anchored) {
                kind TypeKind :: if (cells[i].demand != .none)
                    cells[i].demand
                else if (cells[i].conversion_unsigned)
                    .u64
                else
                    .int

                cells[i].type = if (cells[i].expected.kind == kind)
                    cells[i].expected
                else
                    Type{ kind = kind }
            }
        }
        try prepare_shapes(&state, assignment_values, true)
        if (!assignment_values) try specialize_annotations(&state)
        for (0..count) |i| {
            id :: ast.NodeId(i)
            if (cells[i].role != .expression or cells[i].assignment_value != assignment_values or ast.expr_kind(tree, id) != .call) continue
            if (conversion_kind(&state, id) != .none or state.backings[i].kind != .none) continue
            callee :: ast.call_expr(tree, id).callee
            signature :: group_type(&state, callee)
            if (signature.function != ast.NodeId(maxval!(u32)) or signature.kind == .none or signature.kind == .invalid) continue
            if (group_type(&state, id).kind != .invalid) {
                seed(&state, id, invalid_type(try diagnostics.add(diagnostic_store, .not_callable, ast.node_span(tree, callee))))
            }
        }
        for (0..count) |i| {
            if (assignment_values or cells[i].role != .declaration or types[i].kind == .invalid) continue
            index :: root(&state, i)
            if (cells[index].type.kind != .none) continue
            diagnostic :: try diagnostics.add(diagnostic_store, .cannot_infer_type, ast.statement_decl(tree, ast.NodeId(i)).name)
            cells[index].type = invalid_type(diagnostic)
        }
        for (0..count) |i| {
            if (cells[i].role == .none or cells[i].role == .body or cells[i].assignment_value != assignment_values or types[i].kind == .invalid) continue
            types[i] = cells[root(&state, i)].type
        }
    }
    for (0..count) |i| try validate(&state, ast.NodeId(i))
    for (0..ast.package_decl_count(tree)) |i| {
        id :: ast.package_decl(tree, i)
        if (ast.decl_kind(tree, id) != .function or !ast.function_external(tree, id)) continue
        for (0..i) |j| {
            previous :: ast.package_decl(tree, j)
            if (ast.decl_kind(tree, previous) != .function or !ast.function_external(tree, previous)) continue
            if (ast.name_id(tree, id) == ast.name_id(tree, previous) and !same_signature(&state, id, previous)) {
                try fail(&state, id, .type_mismatch, ast.function_decl(tree, id).name)
            }
        }
    }
    for state.records.items |record| {
        for record.fields |field| {
            if (field.default) |value| try compatible(&state, value, field.type)
        }
    }

    # errors travel only from dependencies to users. A rejected use never poisons
    # an explicitly typed declaration, and body errors do not erase signatures.
    propagate(&state, queue)
    # validate conditions after operand errors have reached their users.
    for (0..count) |i| {
        id :: ast.NodeId(i)
        if (cells[i].role != .if_stmt and cells[i].role != .while_stmt) continue
        condition :: if (cells[i].role == .if_stmt) ast.if_stmt(tree, id).condition else ast.while_stmt(tree, id).condition
        capture :: if (cells[i].role == .if_stmt) ast.if_stmt(tree, id).capture else ast.while_stmt(tree, id).capture
        actual :: types[usize(condition)]
        if (capture != null and actual.kind == .optional) continue
        if (actual.kind != .invalid and (capture != null or actual.kind != .bool or actual.nominal != ast.NodeId(maxval!(u32)))) {
            try fail(&state, condition, .condition_not_bool, ast.node_span(tree, condition))
        }
    }
    for (0..count) |i| {
        if (cells[i].role != .for_stmt) continue
        iterable :: ast.for_stmt(tree, ast.NodeId(i)).iterable
        actual :: types[usize(iterable)]
        if (actual.kind != .invalid and actual.kind != .range) {
            try fail(&state, iterable, .invalid_for_iterable, ast.node_span(tree, iterable))
        }
    }
    propagate(&state, queue)
    fallthroughs hashmap.AutoHashMap(ast.NodeId, diagnostics.DiagnosticId) := hashmap.init(allocator)
    errdefer hashmap.deinit(&fallthroughs)
    for (0..ast.package_decl_count(tree)) |i| {
        id :: ast.package_decl(tree, i)
        if (ast.decl_kind(tree, id) != .function) continue
        if (ast.function_external(tree, id)) continue
        function :: ast.function_decl(tree, id)
        result :: types[usize(function.return_type)]
        if (result.kind == .void or result.kind == .invalid or types[usize(id)].kind == .invalid) continue
        if (result.kind == .fallible and state.arrays.items[usize(result.array_type)].element.kind == .void) continue
        if (block_falls_through(&state, function.body)) {
            # fallthrough is independent of errors in paths that may not execute.
            diagnostic :: try diagnostics.add(diagnostic_store, .missing_return, ast.node_span(tree, function.body))
            hashmap.put(&fallthroughs, id, diagnostic) catch |err| {
                match err {
                    .key_exists: unreachable
                    else: return err
                }
            }
        }
    }
    return Result{ storage = Storage{
        tree = tree,
        types = types,
        arrays = state.arrays,
        pointers = state.pointers,
        records = state.records,
        initializers = state.initializers,
        enums = state.enums,
        backings = backings,
        exhaustive = exhaustive,
        variant_slots = variant_slots,
        slots = slots,
        fallthroughs = fallthroughs,
        allocator = allocator,
    } }
}

#! returns a type without retaining a reference to checker temporaries.
type_of proc(result @Result, id ast.NodeId) Type {
    debug.assert(usize(id) < result.storage.types.len)
    return result.storage.types[usize(id)]
}

#! returns the original diagnostic for a function's nonvoid fallthrough, independent of body errors.
#! null means the function has no fallthrough obligation; lowering still owns trap placement.
fallthrough_diagnostic proc(result @Result, function ast.NodeId) ?diagnostics.DiagnosticId {
    return hashmap.get(&result.storage.fallthroughs, function)
}

array_type_count proc(result @Result) usize {
    return result.storage.arrays.items.len
}

array_type proc(result @Result, id ArrayId) ArrayType {
    debug.assert(usize(id) < result.storage.arrays.items.len)
    return result.storage.arrays.items[usize(id)]
}

pointer_type proc(result @Result, id PointerId) PointerType {
    return result.storage.pointers.items[usize(id)]
}

record_type_count proc(result @Result) usize {
    return result.storage.records.items.len
}

record_type proc(result @Result, id RecordId) RecordType {
    debug.assert(usize(id) < result.storage.records.items.len)
    return result.storage.records.items[usize(id)]
}

enum_type_count proc(result @Result) usize {
    return result.storage.enums.items.len
}

enum_type proc(result @Result, id EnumId) EnumType {
    return result.storage.enums.items[usize(id)]
}

backing_type proc(result @Result, type Type) Type {
    if (type.nominal == ast.NodeId(maxval!(u32))) return type
    return result.storage.backings[usize(type.nominal)]
}

is_type_constructor proc(result @Result, id ast.NodeId) bool {
    return result.storage.backings[usize(id)].kind != .none
}

constructor_backing proc(result @Result, id ast.NodeId) Type {
    return result.storage.backings[usize(id)]
}

match_exhaustive proc(result @Result, id ast.NodeId) bool {
    return result.storage.exhaustive[usize(id)]
}

is_enum_member proc(result @Result, id ast.NodeId) bool {
    return (
        result.storage.backings[usize(id)].kind == .enumeration
        and result.storage.slots[usize(id)] != no_index
    )
}

enum_member_value proc(result @Result, id ast.NodeId) EnumMember {
    type :: result.storage.backings[usize(id)]
    return result.storage.enums.items[usize(type.enum_type)].members[result.storage.slots[usize(id)]]
}

enum_member_index proc(result @Result, id ast.NodeId) usize {
    return result.storage.slots[usize(id)]
}

is_union_variant proc(result @Result, id ast.NodeId) bool {
    return result.storage.variant_slots[usize(id)] != no_index
}

union_variant_index proc(result @Result, id ast.NodeId) usize {
    return result.storage.variant_slots[usize(id)]
}

union_payload_type proc(result @Result, id ast.NodeId) Type {
    return result.storage.backings[usize(id)]
}

field_index proc(result @Result, selection ast.NodeId) usize {
    debug.assert(result.storage.slots[usize(selection)] != no_index)
    return result.storage.slots[usize(selection)]
}

initializer_field proc(result @Result, literal ast.NodeId, index usize) ast.NodeId {
    slot :: result.storage.slots[usize(literal)]
    debug.assert(slot != no_index)
    return result.storage.initializers.items[slot].fields[index]
}

#! releases type, descriptor, and fallthrough storage using the allocator retained by check.
deinit proc(result @mut Result) void {
    mem.free(result.storage.allocator, result.storage.types)
    arraylist.deinit(&result.storage.arrays)
    arraylist.deinit(&result.storage.pointers)
    for (result.storage.enums.items) |descriptor| mem.free(result.storage.allocator, descriptor.members)
    arraylist.deinit(&result.storage.enums)
    mem.free(result.storage.allocator, result.storage.backings)
    mem.free(result.storage.allocator, result.storage.exhaustive)
    mem.free(result.storage.allocator, result.storage.variant_slots)
    hashmap.deinit(&result.storage.fallthroughs)
    for (result.storage.records.items) |record| mem.free(result.storage.allocator, record.fields)
    arraylist.deinit(&result.storage.records)
    for (result.storage.initializers.items) |initializer| mem.free(result.storage.allocator, initializer.fields)
    arraylist.deinit(&result.storage.initializers)
    mem.free(result.storage.allocator, result.storage.slots)
}

@hide:file
propagate proc(state @mut State, queue []mut ast.NodeId) void {
    next := usize(0)
    end := usize(0)
    for (0..(state.types.len)) |i| {
        if (state.types[i].kind != .invalid) continue
        queue[end] = ast.NodeId(i)
        end += 1
    }
    while (next < end) {
        source :: queue[next]
        next += 1
        edge := state.cells[usize(source)].first_edge
        while (edge != no_index) {
            dependent :: state.edges.items[edge].dependent
            if (state.types[usize(dependent)].kind != .invalid) {
                state.types[usize(dependent)] = invalid_type(state.types[usize(source)].diagnostic)
                queue[end] = dependent
                end += 1
            }
            edge = state.edges.items[edge].next
        }
    }
}

@hide:file
require_numeric proc(state @mut State, expression, operand ast.NodeId) void ! (mem.AllocError | diagnostics.CapacityError) {
    index :: root(state, usize(operand))
    type :: state.cells[index].type
    if (type.kind == .invalid) {
        state.types[usize(expression)] = type
        return
    }
    if (type.kind == .none or state.cells[index].numeric or numeric_kind(type.kind)) return
    try fail(state, expression, .invalid_operand, ast.node_span(state.tree, expression))
}

@hide:file
invalid_type proc(diagnostic diagnostics.DiagnosticId) Type {
    return Type{ kind = .invalid, diagnostic = diagnostic }
}

@hide:file
root proc(state @mut State, index usize) usize {
    current := index
    while (state.groups[current].parent != current) current = state.groups[current].parent
    next := index
    while (state.groups[next].parent != next) {
        parent :: state.groups[next].parent
        state.groups[next].parent = current
        next = parent
    }
    return current
}

@hide:file
group_type proc(state @mut State, id ast.NodeId) Type {
    return state.cells[root(state, usize(id))].type
}

@hide:file
seed proc(state @mut State, id ast.NodeId, type Type) void {
    index :: root(state, usize(id))
    if (state.cells[index].type.kind != .invalid) state.cells[index].type = type
}

@hide:file
join proc(state @mut State, left, right ast.NodeId) void {
    a := root(state, usize(left))
    b := root(state, usize(right))
    if (a == b) return
    if (state.groups[a].size < state.groups[b].size) {
        saved :: a
        a = b
        b = saved
    }
    state.groups[b].parent = a
    state.groups[a].size += state.groups[b].size
    if (state.cells[a].type.kind == .none or state.cells[b].type.kind == .invalid) {
        state.cells[a].type = state.cells[b].type
    }
    state.cells[a].numeric = state.cells[a].numeric or state.cells[b].numeric
    state.cells[a].anchored = state.cells[a].anchored or state.cells[b].anchored
    if (state.cells[a].demand == .none) state.cells[a].demand = state.cells[b].demand
    if (state.cells[a].expected.kind == .none) state.cells[a].expected = state.cells[b].expected
    state.cells[a].conversion_unsigned = state.cells[a].conversion_unsigned or state.cells[b].conversion_unsigned
    if (state.cells[a].literal == ast.NodeId(maxval!(u32))) state.cells[a].literal = state.cells[b].literal
    if (state.cells[a].producer == ast.NodeId(maxval!(u32))) state.cells[a].producer = state.cells[b].producer
}

@hide:file
depend proc(state @mut State, source, dependent ast.NodeId) void ! mem.AllocError {
    next :: state.cells[usize(source)].first_edge
    try arraylist.append(&state.edges, Edge{ dependent = dependent, next = next })
    state.cells[usize(source)].first_edge = state.edges.items.len - 1
}

@hide:file
collect_invalid proc(state @mut State, id ast.NodeId) void {
    state.cells[usize(id)].role = .invalid
    state.cells[usize(id)].type = invalid_type(ast.invalid(state.tree, id).diagnostic)
}

@hide:file
check_annotation proc(state @mut State, id ast.NodeId, allow_void bool) Type ! (mem.AllocError | diagnostics.CapacityError) {
    if (state.cells[usize(id)].role == .annotation) return state.types[usize(id)]
    state.cells[usize(id)].role = .annotation
    if (ast.expr_kind(state.tree, id) == .slice_type or ast.expr_kind(state.tree, id) == .optional_type) {
        type :: try check_container_type(state, id)
        state.types[usize(id)] = type
        state.cells[usize(id)].type = type
        return type
    }
    if (ast.expr_kind(state.tree, id) == .pointer_type) {
        type :: try check_pointer_type(state, id)
        state.types[usize(id)] = type
        state.cells[usize(id)].type = type
        return type
    }
    if (type_syntax(ast.expr_kind(state.tree, id))) {
        type :: try check_type_expression(state, id, false)
        state.types[usize(id)] = type
        state.cells[usize(id)].type = type
        return type
    }
    if (ast.expr_kind(state.tree, id) == .array_type) {
        view :: ast.array_type(state.tree, id)
        element := try check_annotation(state, view.element, true)
        element_binding :: sema.binding(state.resolution, view.element)
        if ((element_binding.kind == .builtin
            and (element_binding.data.builtin == .int or element_binding.data.builtin == .float))
            or element.kind == .void or element.kind == .range) {
            element = invalid_type(try diagnostics.add(state.diagnostics, .invalid_array_element_type, ast.node_span(state.tree, view.element)))
            state.types[usize(view.element)] = element
            state.cells[usize(view.element)].type = element
        }
        len := no_index
        type := element
        if (view.count) |count| {
            try collect_expression(state, count)
            if (constant_integer(state, count)) |value| {
                if (!value.negative and value.magnitude <= u64(maxval!(usize))) {
                    len = usize(value.magnitude)
                    if (len == no_index) type = invalid_type(try diagnostics.add(state.diagnostics, .array_size_overflow, ast.node_span(state.tree, count)))
                } else {
                    type = invalid_type(try diagnostics.add(state.diagnostics, .invalid_array_length, ast.node_span(state.tree, count)))
                }
            } else {
                actual :: group_type(state, count)
                type = if (actual.kind == .invalid) actual else invalid_type(try diagnostics.add(state.diagnostics, .invalid_array_length, ast.node_span(state.tree, count)))
            }
        }
        if (type.kind != .invalid) type = try intern_array(state, ArrayType{ element = element, len = len, mutable = view.mutable })
        state.types[usize(id)] = type
        state.cells[usize(id)].type = type
        return type
    }
    binding :: sema.binding(state.resolution, id)
    type := Type{}
    match binding.kind {
        .invalid: type = invalid_type(binding.data.diagnostic)
        .builtin: {
            type.kind = builtin_kind(binding.data.builtin)
            if (type.kind == .anyopaque and state.pointer_depth == 0) {
                type = invalid_type(try diagnostics.add(state.diagnostics, .expected_type, ast.node_span(state.tree, id)))
            }
            if (type.kind == .void and !allow_void) {
                type = invalid_type(try diagnostics.add(state.diagnostics, .invalid_void_type, ast.node_span(state.tree, id)))
            }
        }
        .declaration: {
            target :: binding.data.declaration
            role :: state.cells[usize(target)].role
            if (role != .parameter and role != .loop_capture and ast.decl_kind(state.tree, target) == .statement) {
                initializer :: ast.statement_decl(state.tree, target).initializer
                if (type_syntax(ast.expr_kind(state.tree, initializer))) {
                    type = try check_type_expression(state, initializer, true)
                } else {
                    type = invalid_type(try diagnostics.add(state.diagnostics, .expected_type, ast.node_span(state.tree, id)))
                }
            } else {
                type = invalid_type(try diagnostics.add(state.diagnostics, .expected_type, ast.node_span(state.tree, id)))
            }
        }
        else: type = invalid_type(try diagnostics.add(state.diagnostics, .expected_type, ast.node_span(state.tree, id)))
    }
    state.types[usize(id)] = type
    state.cells[usize(id)].type = type
    return type
}

@hide:file
collect_declaration proc(state @mut State, id ast.NodeId) void ! (mem.AllocError | diagnostics.CapacityError) {
    declaration :: ast.statement_decl(state.tree, id)
    state.cells[usize(id)].role = .declaration
    if (type_syntax(ast.expr_kind(state.tree, declaration.initializer))) {
        state.cells[usize(declaration.initializer)].nominal = true
    }
    if (declaration.type) |type| {
        state.cells[usize(id)].fixed = true
        state.cells[usize(id)].type = try check_annotation(state, type, false)
        try depend(state, type, id)
    }
    binding :: sema.binding(state.resolution, id)
    if (binding.kind == .invalid) {
        state.cells[usize(id)].fixed = true
        state.cells[usize(id)].type = invalid_type(binding.data.diagnostic)
    }
    try collect_expression(state, declaration.initializer)
    if (type_syntax(ast.expr_kind(state.tree, declaration.initializer))
        and state.cells[usize(id)].type.kind != .invalid
        and state.cells[usize(declaration.initializer)].type.kind != .none) {
        state.cells[usize(id)].fixed = true
        state.cells[usize(id)].type = state.cells[usize(declaration.initializer)].type
    }
    try depend(state, declaration.initializer, id)
}

@hide:file
collect_function proc(state @mut State, id ast.NodeId) void ! (mem.AllocError | diagnostics.CapacityError) {
    tree :: state.tree
    function :: ast.function_decl(tree, id)
    state.cells[usize(id)].role = .function
    state.cells[usize(id)].fixed = true
    state.cells[usize(id)].type = Type{ kind = .function, function = id }
    _ = try check_annotation(state, function.return_type, true)
    try depend(state, function.return_type, id)
    for (0..ast.function_param_count(tree, id)) |i| {
        parameter :: ast.function_param(tree, id, i)
        state.cells[usize(parameter)].role = .parameter
        state.cells[usize(parameter)].fixed = true
        state.cells[usize(parameter)].type = try check_annotation(state, ast.param(tree, parameter).type, false)
        binding :: sema.binding(state.resolution, parameter)
        if (binding.kind == .invalid) state.cells[usize(parameter)].type = invalid_type(binding.data.diagnostic)
        try depend(state, ast.param(tree, parameter).type, parameter)
        try depend(state, parameter, id)
    }
    binding :: sema.binding(state.resolution, id)
    if (binding.kind == .invalid) {
        state.cells[usize(id)].type = invalid_type(binding.data.diagnostic)
        state.cells[usize(id)].type.function = id
    }
    if (!ast.function_external(tree, id)) try collect_block(state, function.body, function.return_type, false)
    else {
        if (mem.eql(ast.source_text(tree, function.name), "main")) try fail(state, id, .invalid_entry, function.name)
        if (!c_abi_type(state, state.types[usize(function.return_type)])) try fail(state, id, .invalid_operand, function.span)
        for (0..ast.function_param_count(tree, id)) |i| {
            parameter :: ast.function_param(tree, id, i)
            if (!c_abi_type(state, state.cells[usize(parameter)].type)) try fail(state, id, .invalid_operand, ast.node_span(tree, parameter))
        }
    }
}

@hide:file
collect_capture proc(state @mut State, id, body ast.NodeId) void ! mem.AllocError {
    state.cells[usize(id)].role = .loop_capture
    state.cells[usize(id)].fixed = true
    state.cells[usize(id)].local = true
    state.cells[usize(id)].type = Type{ kind = .int }
    binding :: sema.binding(state.resolution, id)
    if (binding.kind == .invalid) {
        state.cells[usize(id)].type = invalid_type(binding.data.diagnostic)
    }
    try depend(state, id, body)
}

@hide:file
collect_block proc(state @mut State, id, return_annotation ast.NodeId, in_loop bool) void ! (mem.AllocError | diagnostics.CapacityError) {
    saved_annotation :: state.return_annotation
    saved_loop :: state.in_loop
    state.return_annotation = return_annotation
    state.in_loop = in_loop
    defer {
        state.return_annotation = saved_annotation
        state.in_loop = saved_loop
    }
    tree :: state.tree
    state.cells[usize(id)].role = .body
    for (0..ast.block_statement_count(tree, id)) |i| {
        statement :: ast.block_statement(tree, id, i)
        match ast.stmt_kind(tree, statement) {
            .declaration: {
                state.cells[usize(statement)].local = true
                try collect_declaration(state, statement)
            }
            .expression: try collect_expression(state, ast.statement_expr(tree, statement))
            .return_stmt: {
                state.cells[usize(statement)].role = .return_stmt
                state.cells[usize(statement)].type = Type{ kind = .void }
                state.cells[usize(statement)].return_annotation = return_annotation
                if (state.in_cleanup) state.cells[usize(statement)].type = invalid_type(try diagnostics.add(
                    state.diagnostics, .cleanup_control_flow, ast.node_span(tree, statement),
                ))
                if (ast.return_stmt(tree, statement).value) |value| {
                    try collect_expression(state, value)
                    try depend(state, value, statement)
                }
            }
            .if_stmt: {
                conditional :: ast.if_stmt(tree, statement)
                state.cells[usize(statement)].role = .if_stmt
                state.cells[usize(statement)].type = Type{ kind = .void }
                try collect_expression(state, conditional.condition)
                try depend(state, conditional.condition, statement)
                if (conditional.capture) |capture| {
                    try collect_capture(state, capture, conditional.then_block)
                    state.cells[usize(capture)].type = Type{}
                    state.cells[usize(conditional.condition)].capture = capture
                }
                try collect_block(state, conditional.then_block, return_annotation, in_loop)
                try depend(state, conditional.then_block, id)
                if (conditional.else_block) |other| {
                    try collect_block(state, other, return_annotation, in_loop)
                    try depend(state, other, id)
                }
            }
            .assignment_stmt: {
                assignment :: ast.assignment_stmt(tree, statement)
                state.cells[usize(statement)].role = .assignment_stmt
                state.has_assignments = true
                state.cells[usize(statement)].type = Type{ kind = .void }
                binding :: sema.binding(state.resolution, assignment.target)
                if (binding.kind == .builtin or binding.kind == .namespace) {
                    state.cells[usize(assignment.target)].role = .expression
                    state.cells[usize(assignment.target)].type = invalid_type(try diagnostics.add(
                        state.diagnostics, .invalid_assignment_target, ast.node_span(tree, assignment.target),
                    ))
                } else {
                    try collect_expression(state, assignment.target)
                }
                state.collecting_assignment = true
                try collect_expression(state, assignment.value)
                state.collecting_assignment = false
                try depend(state, assignment.target, statement)
                try depend(state, assignment.value, statement)
            }
            .while_stmt: {
                loop :: ast.while_stmt(tree, statement)
                state.cells[usize(statement)].role = .while_stmt
                state.cells[usize(statement)].type = Type{ kind = .void }
                try collect_expression(state, loop.condition)
                try depend(state, loop.condition, statement)
                if (loop.capture) |capture| {
                    try collect_capture(state, capture, loop.body)
                    state.cells[usize(capture)].type = Type{}
                    state.cells[usize(loop.condition)].capture = capture
                }
                try collect_block(state, loop.body, return_annotation, true)
                try depend(state, loop.body, id)
            }
            .for_stmt: {
                loop :: ast.for_stmt(tree, statement)
                state.cells[usize(statement)].role = .for_stmt
                state.cells[usize(statement)].type = Type{ kind = .void }
                state.cells[usize(loop.iterable)].for_iterable = true
                try collect_expression(state, loop.iterable)
                try depend(state, loop.iterable, statement)
                if (loop.pointer_capture) {
                    state.cells[usize(statement)].type = invalid_type(try diagnostics.add(
                        state.diagnostics, .range_pointer_capture, loop.span,
                    ))
                }
                if (loop.index_capture) {
                    diagnostic :: try diagnostics.add(state.diagnostics, .range_index_capture, loop.span)
                    if (state.cells[usize(statement)].type.kind != .invalid) {
                        state.cells[usize(statement)].type = invalid_type(diagnostic)
                    }
                }
                if (loop.capture) |capture| {
                    try collect_capture(state, capture, loop.body)
                    state.cells[usize(loop.iterable)].capture = capture
                }
                if (loop.index) |index| try collect_capture(state, index, loop.body)
                try collect_block(state, loop.body, return_annotation, true)
                try depend(state, loop.body, id)
            }
            .block_stmt: {
                body :: ast.statement_block(tree, statement)
                state.cells[usize(statement)].role = .body
                try collect_block(state, body, return_annotation, in_loop)
                try depend(state, body, statement)
            }
            .defer_stmt, .errdefer_stmt: {
                cleanup :: ast.cleanup_stmt(tree, statement)
                state.cells[usize(statement)].role = .cleanup
                state.cells[usize(statement)].type = Type{ kind = .void }
                result :: state.types[usize(return_annotation)]
                if (ast.stmt_kind(tree, statement) == .errdefer_stmt and result.kind != .fallible and result.kind != .invalid) {
                    state.cells[usize(statement)].type = invalid_type(try diagnostics.add(
                        state.diagnostics, .errdefer_outside_fallible, cleanup.span,
                    ))
                }
                if (cleanup.capture) |capture| {
                    try collect_capture(state, capture, cleanup.body)
                    state.cells[usize(capture)].type = if (result.kind == .fallible)
                        state.arrays.items[usize(result.array_type)].error_type else result
                }
                saved_cleanup :: state.in_cleanup
                state.in_cleanup = true
                try collect_block(state, cleanup.body, return_annotation, false)
                state.in_cleanup = saved_cleanup
            }
            .break_stmt, .continue_stmt: {
                state.cells[usize(statement)].role = .loop_control
                state.cells[usize(statement)].type = Type{ kind = .void }
                if (!in_loop) {
                    code :: if (state.in_cleanup) diagnostics.Code.cleanup_control_flow
                    else if (ast.stmt_kind(tree, statement) == .break_stmt)
                        diagnostics.Code.break_outside_loop
                    else
                        diagnostics.Code.continue_outside_loop
                    state.cells[usize(statement)].type = invalid_type(try diagnostics.add(
                        state.diagnostics, code, ast.node_span(tree, statement),
                    ))
                }
            }
            .invalid: collect_invalid(state, statement)
        }
        source :: if (ast.stmt_kind(tree, statement) == .expression) ast.statement_expr(tree, statement) else statement
        try depend(state, source, id)
    }
}

@hide:file
collect_expression proc(state @mut State, id ast.NodeId) void ! (mem.AllocError | diagnostics.CapacityError) {
    if (state.cells[usize(id)].role != .none) return
    tree :: state.tree
    state.cells[usize(id)].role = .expression
    state.cells[usize(id)].assignment_value = state.collecting_assignment
    state.cells[usize(id)].return_annotation = state.return_annotation
    state.cells[usize(id)].in_cleanup = state.in_cleanup
    state.cells[usize(id)].narrowing_arm = state.narrowing_arm
    match ast.expr_kind(tree, id) {
        .comptime_expr: try fail(state, id, .comptime_argument_required, ast.node_span(tree, id))
        .typed_constant: {
            value :: ast.typed_constant(tree, id)
            state.cells[usize(id)].fixed = true
            state.cells[usize(id)].type = try check_annotation(state, value.type, false)
            try collect_expression(state, value.value)
            try depend(state, value.type, id)
            try depend(state, value.value, id)
        }
        .try_expr: {
            operand :: ast.type_operand(tree, id)
            try collect_expression(state, operand)
            try depend(state, operand, id)
        }
        .catch_expr: {
            expression :: ast.catch_expr(tree, id)
            try collect_expression(state, expression.operand)
            try depend(state, expression.operand, id)
            if (expression.capture) |capture| {
                try collect_capture(state, capture, expression.handler)
                state.cells[usize(capture)].type = Type{}
            }
            if (expression.handler_is_block) {
                try collect_block(state, expression.handler, state.return_annotation, state.in_loop)
            } else try collect_expression(state, expression.handler)
        }
        .literal_int: {
            state.cells[usize(id)].numeric = true
            state.cells[usize(id)].anchored = true
        }
        .literal_float: {
            state.cells[usize(id)].type = Type{ kind = .float }
            state.cells[usize(id)].numeric = true
            state.cells[usize(id)].anchored = true
            state.cells[usize(id)].demand = .float
        }
        .literal_bool: state.cells[usize(id)].type = Type{ kind = .bool }
        .literal_string: state.cells[usize(id)].type = Type{ kind = .string }
        .literal_null: state.cells[usize(id)].type = Type{ kind = .null }
        .literal_void: state.cells[usize(id)].type = Type{ kind = .void }
        .builtin_call: try collect_builtin(state, id)
        .slice: {
            view :: ast.slice_expr(tree, id)
            try collect_expression(state, view.base)
            try depend(state, view.base, id)
            if (view.start) |child| {
                try collect_expression(state, child)
                try depend(state, child, id)
            }
            if (view.end) |child| {
                try collect_expression(state, child)
                try depend(state, child, id)
            }
            if (view.sentinel) |child| {
                try collect_expression(state, child)
                try depend(state, child, id)
            }
        }
        .identifier, .selection: {
            binding :: sema.binding(state.resolution, id)
            if (binding.kind == .none and ast.expr_kind(tree, id) == .selection) {
                base :: ast.selection_expr(tree, id).base
                if (type_reference(state, base)) {
                    checked :: try check_annotation(state, base, true)
                    if (checked.kind != .invalid
                        and (checked.kind != .enumeration or checked.nominal != ast.NodeId(maxval!(u32)))) {
                        try fail(state, base, .type_not_value, ast.node_span(tree, base))
                        state.cells[usize(base)].type = state.types[usize(base)]
                    }
                } else try collect_expression(state, base)
                try depend(state, base, id)
            }
            if (binding.kind == .declaration) {
                target :: binding.data.declaration
                role :: state.cells[usize(target)].role
                if (role != .parameter and role != .loop_capture and ast.decl_kind(tree, target) == .statement
                    and type_syntax(ast.expr_kind(tree, ast.statement_decl(tree, target).initializer))) {
                    state.cells[usize(id)].type = invalid_type(try diagnostics.add(state.diagnostics, .type_not_value, ast.node_span(tree, id)))
                }
            }
            match binding.kind {
                .invalid: state.cells[usize(id)].type = invalid_type(binding.data.diagnostic)
                .builtin: state.cells[usize(id)].type = invalid_type(try diagnostics.add(state.diagnostics, .type_not_value, ast.node_span(tree, id)))
                .namespace: state.cells[usize(id)].type = invalid_type(try diagnostics.add(state.diagnostics, .namespace_not_value, ast.node_span(tree, id)))
                else: {}
            }
        }
        .unary: {
            expression :: ast.unary_expr(tree, id)
            if (expression.operator == .negate) state.cells[usize(id)].producer = id
            if (expression.operator == .logical_not) {
                state.cells[usize(id)].type = Type{ kind = .bool }
            } else if (expression.operator == .negate) {
                state.cells[usize(id)].numeric = true
            }
            operand :: expression.operand
            try collect_expression(state, operand)
            try depend(state, operand, id)
        }
        .binary: {
            expression :: ast.binary_expr(tree, id)
            if (!comparison(expression.operator) and !logical(expression.operator)) state.cells[usize(id)].producer = id
            if (comparison(expression.operator) or logical(expression.operator)) {
                state.cells[usize(id)].type = Type{ kind = .bool }
            } else {
                state.cells[usize(id)].numeric = true
            }
            try collect_expression(state, expression.left)
            try collect_expression(state, expression.right)
            try depend(state, expression.left, id)
            # the RHS may be skipped, so its errors do not erase the bool result.
            if (!logical(expression.operator)) try depend(state, expression.right, id)
        }
        .range: {
            expression :: ast.range_expr(tree, id)
            state.cells[usize(id)].type = Type{ kind = .range }
            if (!state.cells[usize(id)].for_iterable and !state.cells[usize(id)].match_pattern) {
                state.cells[usize(id)].type = invalid_type(try diagnostics.add(
                    state.diagnostics, .range_value_not_supported, expression.span,
                ))
            }
            try collect_expression(state, expression.start)
            try collect_expression(state, expression.end)
            try depend(state, expression.start, id)
            try depend(state, expression.end, id)
        }
        .call: {
            callee :: ast.call_expr(tree, id).callee
            destination :: conversion_kind(state, id)
            if (destination != .none) {
                state.cells[usize(callee)].role = .annotation
                state.cells[usize(callee)].type = Type{ kind = destination }
                state.types[usize(callee)] = Type{ kind = destination }
                state.cells[usize(id)].type = Type{ kind = destination }
            } else if (type_reference(state, callee)) {
                destination_type :: try check_annotation(state, callee, true)
                state.cells[usize(id)].type = destination_type
                state.backings[usize(id)] = immediate_backing(state, destination_type)
            } else {
                try collect_expression(state, callee)
                try depend(state, callee, id)
            }
            for (0..ast.call_arg_count(tree, id)) |i| {
                argument :: ast.call_arg(tree, id, i)
                try collect_expression(state, argument)
                try depend(state, argument, id)
            }
        }
        .array_type: {
            state.cells[usize(id)].type = invalid_type(try diagnostics.add(state.diagnostics, .type_not_value, ast.node_span(tree, id)))
        }
        .record_type, .union_type, .enum_type, .distinct_type,
        .pointer_type, .function_type, .slice_type, .optional_type, .fallible_type, .sum_type: {
            type := try check_type_expression(state, id, state.cells[usize(id)].nominal)
            if (type.kind != .invalid) {
                type.value_kind = type.kind
                type.kind = .type_value
            }
            state.cells[usize(id)].type = type
        }
        .enum_literal: state.cells[usize(id)].literal = id
        .match_expr: try collect_match(state, id)
        .alias_expr: {
            operand :: ast.type_operand(tree, id)
            if (type_reference(state, operand)) {
                type := try check_type_expression(state, id, false)
                if (type.kind != .invalid) {
                    type.value_kind = type.kind
                    type.kind = .type_value
                }
                state.cells[usize(id)].type = type
            } else {
                try collect_expression(state, operand)
                join(state, id, operand)
                try depend(state, operand, id)
            }
        }
        .record_literal: {
            state.cells[usize(id)].literal = id
            if (ast.record_literal(tree, id).type) |annotation| {
                if (ast.expr_kind(tree, annotation) == .enum_literal) {
                    try collect_expression(state, annotation)
                } else {
                    state.cells[usize(id)].expected = try check_annotation(state, annotation, false)
                    try depend(state, annotation, id)
                }
            }
            for 0..ast.record_field_count(tree, id) |i| {
                value :: ast.field(tree, ast.record_field(tree, id, i)).value?
                try collect_expression(state, value)
                try depend(state, value, id)
            }
        }
        .array_literal: {
            state.cells[usize(id)].literal = id
            for 0..ast.array_element_count(tree, id) |i| {
                element :: ast.array_element(tree, id, i)
                try collect_expression(state, element)
                try depend(state, element, id)
            }
        }
        .index: {
            expression :: ast.index_expr(tree, id)
            try collect_expression(state, expression.base)
            try collect_expression(state, expression.index)
            try depend(state, expression.base, id)
            try depend(state, expression.index, id)
        }
        .invalid: collect_invalid(state, id)
    }
}

@hide:file
declaration_reference proc(tree @ast.Tree, id ast.NodeId) bool {
    kind :: ast.expr_kind(tree, id)
    return kind == .identifier or kind == .selection
}

@hide:file
integer_kind proc(kind TypeKind) bool {
    return (
        kind == .int or kind == .i8 or kind == .i16 or kind == .i32 or kind == .isize
        or unsigned_kind(kind)
    )
}

@hide:file
unsigned_kind proc(kind TypeKind) bool {
    return kind == .u8 or kind == .u16 or kind == .u32 or kind == .u64 or kind == .usize
}

@hide:file
numeric_kind proc(kind TypeKind) bool {
    return integer_kind(kind) or kind == .float
}

@hide:file
builtin_kind proc(type sema.BuiltinType) TypeKind {
    return match type {
        .int, .i64: .int
        .float, .f64: .float
        .i8: .i8
        .i16: .i16
        .i32: .i32
        .isize: .isize
        .u8: .u8
        .u16: .u16
        .u32: .u32
        .u64, .uint: .u64
        .usize: .usize
        .bool: .bool
        .string: .string
        .void: .void
        .anyopaque: .anyopaque
        .type: .type_value
        .c_int: .i32
        .c_uint: .u32
        .c_long, .c_longlong: .int
        .c_ulong, .c_ulonglong: .u64
        .c_char: .i8
        .c_uchar: .u8
        .c_short: .i16
        .c_ushort: .u16
    }
}

@hide:file
conversion_kind proc(state @State, id ast.NodeId) TypeKind {
    callee :: ast.call_expr(state.tree, id).callee
    binding :: sema.binding(state.resolution, callee)
    if (binding.kind != .builtin) return .none
    kind :: builtin_kind(binding.data.builtin)
    return if (numeric_kind(kind)) kind else .none
}

@hide:file
comparison proc(operator ast.BinaryOperator) bool {
    return (
        operator == .equal or operator == .not_equal or operator == .less
        or operator == .less_equal or operator == .greater or operator == .greater_equal
    )
}

@hide:file
logical proc(operator ast.BinaryOperator) bool {
    return operator == .logical_and or operator == .logical_or
}

@hide:file
pointer_addition proc(state @mut State, id ast.NodeId) bool {
    expression :: ast.binary_expr(state.tree, id)
    left :: group_type(state, expression.left)
    return (
        expression.operator == .add and left.kind == .pointer
        and left.nominal == ast.NodeId(maxval!(u32))
        and state.pointers.items[usize(left.pointer_type)].many
        and state.pointers.items[usize(left.pointer_type)].element.kind != .anyopaque
    )
}

@hide:file
bool_equality proc(state @mut State, id ast.NodeId) bool {
    expression :: ast.binary_expr(state.tree, id)
    left :: group_type(state, expression.left)
    right :: group_type(state, expression.right)
    return (
        (expression.operator == .equal or expression.operator == .not_equal)
        and ((left.kind == .bool and right.kind == .bool)
            or left.kind == .enumeration or right.kind == .enumeration
            or left.kind == .pointer or right.kind == .pointer
            or left.kind == .optional or right.kind == .optional
            or left.kind == .null or right.kind == .null)
    )
}

@hide:file
comparison_operands proc(state @mut State, id ast.NodeId) void ! (mem.AllocError | diagnostics.CapacityError) {
    if (state.types[usize(id)].kind == .invalid) return
    expression :: ast.binary_expr(state.tree, id)
    left :: root(state, usize(expression.left))
    right :: root(state, usize(expression.right))
    # only operand groups receive numeric demands; the result stays bool.
    if (state.cells[left].numeric or state.cells[left].type.kind == .none) {
        state.cells[left].numeric = true
        try numeric_constraint(state, expression.left, expression.right, id)
    } else if (state.cells[right].numeric or state.cells[right].type.kind == .none) {
        state.cells[right].numeric = true
        try numeric_constraint(state, expression.right, expression.left, id)
    }
}

@hide:file
impose proc(state @mut State, id ast.NodeId, kind TypeKind, code diagnostics.Code, span ast.Span) void ! (mem.AllocError | diagnostics.CapacityError) {
    index :: root(state, usize(id))
    if (state.cells[index].type.kind == .invalid) return
    state.cells[index].anchored = true
    if (state.cells[index].demand == .none) {
        state.cells[index].demand = kind
    } else if (state.cells[index].demand != kind) {
        state.cells[index].type = invalid_type(try diagnostics.add(state.diagnostics, code, span))
    }
}

@hide:file
numeric_operand proc(state @mut State, expression, operand ast.NodeId) void ! (mem.AllocError | diagnostics.CapacityError) {
    try numeric_constraint(state, expression, operand, expression)
}

@hide:file
numeric_constraint proc(state @mut State, expression, operand, operation ast.NodeId) void ! (mem.AllocError | diagnostics.CapacityError) {
    index :: root(state, usize(operand))
    type :: state.cells[index].type
    if (state.types[usize(expression)].kind == .invalid or state.types[usize(operand)].kind == .invalid) return
    if (group_type(state, expression).kind == .invalid) return
    if (state.cells[index].numeric or type.kind == .none) {
        expression_demand :: state.cells[root(state, usize(expression))].demand
        operand_demand :: state.cells[index].demand
        a :: state.cells[root(state, usize(expression))].expected
        b :: state.cells[index].expected
        if (a.kind != .none and b.kind != .none and !same_type(state, a, b)) {
            try fail(state, operation, .invalid_operand, ast.node_span(state.tree, operation))
            return
        }
        join(state, expression, operand)
        if (expression_demand != .none) {
            try impose(state, expression, expression_demand, .invalid_operand, ast.node_span(state.tree, operation))
        }
        if (operand_demand != .none) {
            try impose(state, expression, operand_demand, .invalid_operand, ast.node_span(state.tree, operation))
        }
    } else if (numeric_kind(type.kind)) {
        try demand(state, expression, type, .invalid_operand)
    }
}

@hide:file
demand proc(state @mut State, id ast.NodeId, expected Type, code diagnostics.Code) void ! (mem.AllocError | diagnostics.CapacityError) {
    if (state.types[usize(id)].kind == .invalid) return
    index :: root(state, usize(id))
    if (state.cells[usize(id)].role == .expression and ast.expr_kind(state.tree, id) == .builtin_call) {
        name :: builtin_name(state, id)
        if (mem.eql(name, "ptrcast") or mem.eql(name, "constcast")) {
            state.cells[index].expected = expected
            seed(state, id, expected)
            return
        }
    }
    if (expected.kind == .fallible) {
        descriptor :: state.arrays.items[usize(expected.array_type)]
        actual := group_type(state, id)
        if (state.cells[usize(id)].role == .expression and declaration_reference(state.tree, id)
            and has_narrowing(state, id)) actual = try infer_shape(state, id, false)
        if (actual.kind == .fallible) return
        target := descriptor.element
        literal :: state.cells[index].literal
        if (actual.kind == .none and state.cells[index].expected.kind != .none) actual = state.cells[index].expected
        if (literal != ast.NodeId(maxval!(u32))) {
            name := ast.NodeId(maxval!(u32))
            if (ast.expr_kind(state.tree, literal) == .enum_literal) name = ast.enum_literal(state.tree, literal)
            if (ast.expr_kind(state.tree, literal) == .record_literal) {
                if (ast.record_literal(state.tree, literal).type) |annotation| {
                    if (ast.expr_kind(state.tree, annotation) == .enum_literal) name = ast.enum_literal(state.tree, annotation)
                }
                if (name == ast.NodeId(maxval!(u32)) and actual.kind == .none
                    and descriptor.element.kind != .record and descriptor.error_type.kind == .record
                    and !state.records.items[usize(descriptor.error_type.record_type)].is_union) target = descriptor.error_type
            }
            if (name != ast.NodeId(maxval!(u32)) and type_has_variant(state, descriptor.error_type, name)
                and !type_has_variant(state, descriptor.element, name)) target = descriptor.error_type
            else if (actual.kind != .none and !assignable_type(state, actual, target)
                and assignable_type(state, actual, descriptor.error_type)) target = descriptor.error_type
        } else if (actual.kind != .none and !assignable_type(state, actual, target)
            and assignable_type(state, actual, descriptor.error_type)) target = descriptor.error_type
        try demand(state, id, target, code)
        return
    }
    if (expected.kind == .optional) {
        if (group_type(state, id).kind != .optional and group_type(state, id).kind != .null) {
            try demand(state, id, state.arrays.items[usize(expected.array_type)].element, code)
        }
        return
    }
    if (expected.kind == .slice) {
        state.cells[index].expected = expected
        if (ast.expr_kind(state.tree, id) == .unary and ast.unary_expr(state.tree, id).operator == .address_of) {
            operand :: ast.unary_expr(state.tree, id).operand
            if (ast.expr_kind(state.tree, operand) == .array_literal) {
                descriptor :: state.arrays.items[usize(expected.array_type)]
                array :: try intern_array(state, ArrayType{
                    element = descriptor.element, len = ast.array_element_count(state.tree, operand), mutable = descriptor.mutable,
                })
                try demand(state, operand, array, code)
                seed(state, id, expected)
            }
        } else if (ast.expr_kind(state.tree, id) == .array_literal) {
            descriptor :: state.arrays.items[usize(expected.array_type)]
            array :: try intern_array(state, ArrayType{
                element = descriptor.element, len = ast.array_element_count(state.tree, id), mutable = descriptor.mutable,
            })
            try demand(state, id, array, code)
        }
        return
    }
    if (expected.kind == .pointer and state.cells[usize(id)].role == .expression
        and ast.expr_kind(state.tree, id) == .unary
        and ast.unary_expr(state.tree, id).operator == .address_of) {
        state.cells[index].expected = expected
        try demand(state, ast.unary_expr(state.tree, id).operand,
            state.pointers.items[usize(expected.pointer_type)].element, code)
        return
    }
    if (state.cells[usize(id)].role == .expression and ast.expr_kind(state.tree, id) == .match_expr) {
        state.cells[index].expected = expected
        for 0..ast.match_arm_count(state.tree, id) |i| {
            arm :: ast.match_arm_view(state.tree, ast.match_arm(state.tree, id, i))
            if (arm.expression) try demand(state, arm.body, expected, code)
        }
        return
    }
    literal_node :: state.cells[index].literal
    if (expected.nominal != ast.NodeId(maxval!(u32))
        and (expected.kind == .record or expected.kind == .array)) return
    if (literal_node != ast.NodeId(maxval!(u32)) and ast.expr_kind(state.tree, literal_node) == .enum_literal) {
        previous :: state.cells[index].expected
        if (previous.kind != .none and !same_type(state, previous, expected)) {
            try fail(state, id, code, ast.node_span(state.tree, id))
            return
        }
        state.cells[index].expected = expected
        _ = try infer_enum_literal(state, literal_node, expected, false)
        return
    }
    if (expected.kind == .record) {
        literal :: state.cells[index].literal
        if (literal == ast.NodeId(maxval!(u32)) or ast.expr_kind(state.tree, literal) != .record_literal) return
        annotation :: ast.record_literal(state.tree, literal).type
        contextual :: annotation == null or ast.expr_kind(state.tree, annotation?) == .enum_literal
        if (contextual) {
            previous :: state.cells[index].expected
            if (previous.kind == .record and !same_type(state, previous, expected)) {
                try fail(state, literal, code, ast.node_span(state.tree, literal))
                return
            }
            state.cells[index].expected = expected
        }
        _ = try infer_record_literal(state, literal, index, false)
        return
    }
    if (expected.kind == .array) {
        literal :: state.cells[index].literal
        if (literal == ast.NodeId(maxval!(u32))) return
        if (ast.expr_kind(state.tree, literal) != .array_literal) return
        previous :: state.cells[index].expected
        if (previous.kind == .array and !same_type(state, previous, expected)) {
            if (!has_inferred_count(state, previous) and !has_inferred_count(state, expected)) {
                state.cells[index].type = invalid_type(try diagnostics.add(state.diagnostics, code, ast.node_span(state.tree, id)))
                return
            }
        }
        state.cells[index].expected = expected
        descriptor :: state.arrays.items[usize(expected.array_type)]
        len :: ast.array_element_count(state.tree, literal)
        if (descriptor.len != no_index and descriptor.len != len) {
            try fail(state, literal, .array_length_mismatch, ast.node_span(state.tree, literal))
        }
        for (0..len) |i| try demand(state, ast.array_element(state.tree, literal, i), descriptor.element, code)
        return
    }
    if (!numeric_kind(expected.kind)) return
    if (!state.cells[index].numeric and state.cells[index].type.kind != .none) return
    state.cells[index].numeric = true
    if (state.cells[index].expected.kind != .none
        and !same_type(state, state.cells[index].expected, expected)) {
        state.cells[index].type = invalid_type(try diagnostics.add(state.diagnostics, code, ast.node_span(state.tree, id)))
        return
    }
    state.cells[index].expected = expected
    try impose(state, id, expected.kind, code, ast.node_span(state.tree, id))
}

@hide:file
range_bound_context proc(state @mut State, id ast.NodeId, family TypeKind) void ! (mem.AllocError | diagnostics.CapacityError) {
    if (state.types[usize(id)].kind == .invalid) return
    index :: root(state, usize(id))
    if (state.cells[index].type.kind == .invalid) return
    if (state.cells[index].demand != .none and state.cells[index].demand != family) {
        try fail(state, id, .invalid_range_bound, ast.node_span(state.tree, id))
        return
    }
    try demand(state, id, Type{ kind = family }, .invalid_range_bound)
}

@hide:file
fail proc(state @mut State, id ast.NodeId, code diagnostics.Code, span ast.Span) void ! (mem.AllocError | diagnostics.CapacityError) {
    if (state.types[usize(id)].kind == .invalid) return
    state.types[usize(id)] = invalid_type(try diagnostics.add(state.diagnostics, code, span))
}

@hide:file
require_bool proc(state @mut State, operand ast.NodeId) void ! (mem.AllocError | diagnostics.CapacityError) {
    type :: state.types[usize(operand)]
    if (type.kind != .invalid and (type.kind != .bool or type.nominal != ast.NodeId(maxval!(u32)))) {
        try fail(state, operand, .invalid_operand, ast.node_span(state.tree, operand))
    }
}

@hide:file
mutable_target proc(state @mut State, id ast.NodeId, allow_global bool) bool {
    kind :: ast.expr_kind(state.tree, id)
    if (kind == .unary) {
        view :: ast.unary_expr(state.tree, id)
        base :: group_type(state, view.operand)
        return (
            view.operator == .dereference and base.kind == .pointer
            and state.pointers.items[usize(base.pointer_type)].mutable
        )
    }
    if (kind == .index) {
        view :: ast.index_expr(state.tree, id)
        base :: group_type(state, view.base)
        if (base.kind == .pointer) {
            pointer :: state.pointers.items[usize(base.pointer_type)]
            return pointer.mutable and (pointer.many
                or (pointer.element.kind == .array and state.arrays.items[usize(pointer.element.array_type)].mutable))
        }
        if (base.kind == .slice) return state.arrays.items[usize(base.array_type)].mutable
        return base.kind == .array and state.arrays.items[usize(base.array_type)].mutable and mutable_target(state, view.base, allow_global)
    }
    if (kind == .selection and sema.binding(state.resolution, id).kind == .none) {
        view :: ast.selection_expr(state.tree, id)
        base :: group_type(state, view.base)
        if (base.kind == .pointer) {
            pointer :: state.pointers.items[usize(base.pointer_type)]
            return pointer.element.kind == .record and pointer.mutable
        }
        return base.kind == .record and mutable_target(state, view.base, allow_global)
    }
    binding :: sema.binding(state.resolution, id)
    if (binding.kind != .declaration) return false
    target :: binding.data.declaration
    if (state.cells[usize(target)].role != .declaration or (!allow_global and !state.cells[usize(target)].local)) return false
    return ast.statement_decl(state.tree, target).mutability == .variable
}

@hide:file
indexable_type proc(state @State, type Type) bool {
    if (type.nominal != ast.NodeId(maxval!(u32))) return false
    if (type.kind == .array or type.kind == .slice or type.kind == .string) return true
    if (type.kind != .pointer) return false
    pointer :: state.pointers.items[usize(type.pointer_type)]
    return (pointer.many and pointer.element.kind != .anyopaque) or pointer.element.kind == .array
}

@hide:file
addressable_target proc(state @mut State, id ast.NodeId) bool {
    kind :: ast.expr_kind(state.tree, id)
    if (kind == .unary) {
        view :: ast.unary_expr(state.tree, id)
        return view.operator == .dereference and group_type(state, view.operand).kind == .pointer
    }
    if (kind == .index) {
        view :: ast.index_expr(state.tree, id)
        base :: group_type(state, view.base)
        return indexable_type(state, base) and (base.kind == .pointer or base.kind == .slice or base.kind == .string or addressable_target(state, view.base))
    }
    if (kind == .selection and sema.binding(state.resolution, id).kind == .none) {
        view :: ast.selection_expr(state.tree, id)
        base :: group_type(state, view.base)
        if (base.kind == .pointer) {
            pointer :: state.pointers.items[usize(base.pointer_type)]
            return pointer.element.kind == .record
        }
        return base.kind == .record and addressable_target(state, view.base)
    }
    binding :: sema.binding(state.resolution, id)
    if (binding.kind != .declaration) return false
    role :: state.cells[usize(binding.data.declaration)].role
    return role == .declaration or role == .parameter or role == .loop_capture
}

@hide:file
same_signature proc(state @State, left, right ast.NodeId) bool {
    if (left == right) return true
    if (ast.function_external(state.tree, left) != ast.function_external(state.tree, right)) return false
    tree :: state.tree
    if (ast.function_param_count(tree, left) != ast.function_param_count(tree, right)) return false
    left_result :: ast.callable_result(tree, left)
    right_result :: ast.callable_result(tree, right)
    if (!same_type(state, state.types[usize(left_result)], state.types[usize(right_result)])) return false
    for (0..ast.function_param_count(tree, left)) |i| {
        left_param :: ast.param(tree, ast.function_param(tree, left, i)).type
        right_param :: ast.param(tree, ast.function_param(tree, right, i)).type
        if (!same_type(state, state.types[usize(left_param)], state.types[usize(right_param)])) return false
    }
    return true
}

@hide:file
assignable_type proc(state @State, actual, expected Type) bool {
    if (same_type(state, actual, expected)) return true
    if (expected.kind == .fallible) {
        target :: state.arrays.items[usize(expected.array_type)]
        if (actual.kind == .fallible) {
            source :: state.arrays.items[usize(actual.array_type)]
            return (
                assignable_type(state, source.element, target.element)
                and error_subset(state.records.items, state.enums.items, source.error_type, target.error_type)
            )
        }
        return (
            assignable_type(state, actual, target.element)
            or error_subset(state.records.items, state.enums.items, actual, target.error_type)
        )
    }
    if ((composed_type(state, actual) or composed_type(state, expected))
        and error_subset(state.records.items, state.enums.items, actual, expected)) return true
    if (expected.kind == .optional) {
        child :: state.arrays.items[usize(expected.array_type)].element
        if (actual.kind == .null) return true
        if (actual.kind == .optional) {
            source :: state.arrays.items[usize(actual.array_type)].element
            if (source.kind != child.kind) return false
            return assignable_type(state, source, child)
        }
        return assignable_type(state, actual, child)
    }
    if (expected.kind == .slice) {
        b :: state.arrays.items[usize(expected.array_type)]
        if (actual.kind == .string) return !b.mutable and b.element.kind == .u8 and (b.sentinel == null or b.sentinel? == 0)
        if (actual.kind == .slice or actual.kind == .array) {
            a :: state.arrays.items[usize(actual.array_type)]
            return (
                (!b.mutable or a.mutable) and (b.sentinel == null or same_sentinel(a.sentinel, b.sentinel))
                and same_type(state, a.element, b.element)
            )
        }
    }
    if (actual.kind != .pointer or expected.kind != .pointer or actual.nominal != expected.nominal) return false
    a :: state.pointers.items[usize(actual.pointer_type)]
    b :: state.pointers.items[usize(expected.pointer_type)]
    if (a.many != b.many or (!a.mutable and b.mutable)) return false
    if (b.element.kind == .anyopaque) return true
    if (b.mutable) return same_type(state, a.element, b.element)
    return assignable_type(state, a.element, b.element)
}

@hide:file
composed_type proc(state @State, type Type) bool {
    if (type.kind == .enumeration) return state.enums.items[usize(type.enum_type)].composed
    if (type.kind == .record) return state.records.items[usize(type.record_type)].composed
    return false
}

@hide:file
compatible proc(state @mut State, value ast.NodeId, expected Type) void ! (mem.AllocError | diagnostics.CapacityError) {
    actual :: state.types[usize(value)]
    if (actual.kind == .invalid or expected.kind == .invalid) return
    if (!assignable_value(state, value, actual, expected)) {
        try fail(state, value, .type_mismatch, ast.node_span(state.tree, value))
    }
}

@hide:file
assignable_value proc(state @mut State, value ast.NodeId, actual, expected Type) bool {
    if (!assignable_type(state, actual, expected)) return false
    target := expected
    while (target.kind == .optional) target = state.arrays.items[usize(target.array_type)].element
    if (actual.kind == .array and target.kind == .slice
        and state.arrays.items[usize(target.array_type)].mutable
        and addressable_target(state, value)) return mutable_target(state, value, true)
    return true
}

@hide:file
validate proc(state @mut State, id ast.NodeId) void ! (mem.AllocError | diagnostics.CapacityError) {
    tree :: state.tree
    if (state.cells[usize(id)].role == .expression and ast.expr_kind(tree, id) == .match_expr) {
        try validate_match(state, id)
        return
    }
    match state.cells[usize(id)].role {
        .declaration: {
            declaration :: ast.statement_decl(tree, id)
            if (declaration.type == null and state.types[usize(declaration.initializer)].kind == .null) {
                try fail(state, declaration.initializer, .cannot_infer_type, ast.node_span(tree, declaration.initializer))
            }
            if (state.types[usize(declaration.initializer)].kind == .void) {
                try fail(state, declaration.initializer, .type_mismatch, ast.node_span(tree, declaration.initializer))
            }
            if (declaration.type) |type| try compatible(state, declaration.initializer, state.types[usize(type)])
        }
        .assignment_stmt: {
            assignment :: ast.assignment_stmt(tree, id)
            target_type :: state.types[usize(assignment.target)]
            if (target_type.kind == .invalid) return
            if (mutable_target(state, assignment.target, false)) {
                try compatible(state, assignment.value, target_type)
            } else {
                kind :: ast.expr_kind(tree, assignment.target)
                code := if (kind == .index) diagnostics.Code.invalid_index_assignment else diagnostics.Code.invalid_assignment_target
                if (kind == .unary and ast.unary_expr(tree, assignment.target).operator == .dereference) {
                    code = .invalid_pointer_assignment
                } else if (kind == .index and state.types[usize(ast.index_expr(tree, assignment.target).base)].kind == .pointer) {
                    code = .invalid_pointer_assignment
                } else if (kind == .selection and state.types[usize(ast.selection_expr(tree, assignment.target).base)].kind == .pointer) {
                    code = .invalid_pointer_assignment
                }
                try fail(state, id, code, ast.node_span(tree, assignment.target))
            }
        }
        .return_stmt: {
            statement :: ast.return_stmt(tree, id)
            expected :: state.types[usize(state.cells[usize(id)].return_annotation)]
            if (expected.kind == .invalid) return
            if (state.types[usize(id)].kind == .invalid) return
            if (statement.value) |value| {
                actual :: state.types[usize(value)]
                if (actual.kind == .invalid) {
                    state.types[usize(id)] = actual
                } else if (!assignable_value(state, value, actual, expected)) {
                    try fail(state, value, .return_type_mismatch, ast.node_span(tree, value))
                    state.types[usize(id)] = state.types[usize(value)]
                }
            } else if (expected.kind != .void
                and !(expected.kind == .fallible and state.arrays.items[usize(expected.array_type)].element.kind == .void)) {
                try fail(state, id, .return_type_mismatch, statement.span)
            }
        }
        .expression: {
            match ast.expr_kind(tree, id) {
                .typed_constant: {
                    value :: ast.typed_constant(tree, id)
                    try compatible(state, value.value, state.cells[usize(id)].type)
                }
                .try_expr, .catch_expr: try validate_fallible_expression(state, id)
                .unary: {
                    expression :: ast.unary_expr(tree, id)
                    if (expression.operator == .logical_not) {
                        try require_bool(state, expression.operand)
                        return
                    }
                    if (expression.operator == .address_of) {
                        if (!addressable_target(state, expression.operand)) {
                            if (state.types[usize(id)].kind == .slice) return
                            try fail(state, id, .invalid_address_operand, expression.span)
                        }
                        return
                    }
                    if (expression.operator == .unwrap) {
                        if (state.types[usize(expression.operand)].kind != .optional and state.types[usize(expression.operand)].kind != .invalid) {
                            try fail(state, id, .invalid_operand, expression.span)
                        }
                        return
                    }
                    if (expression.operator == .dereference) {
                        if (state.types[usize(expression.operand)].kind != .invalid
                            and state.types[usize(expression.operand)].kind != .pointer) {
                            try fail(state, id, .invalid_dereference, expression.span)
                        }
                        return
                    }
                    operand :: state.types[usize(expression.operand)]
                    if (operand.kind != .invalid and (!numeric_kind(operand.kind) or unsigned_kind(operand.kind))) {
                        try fail(state, id, .invalid_operand, ast.node_span(tree, id))
                    }
                }
                .binary: {
                    expression :: ast.binary_expr(tree, id)
                    if (logical(expression.operator)) {
                        try require_bool(state, expression.left)
                        try require_bool(state, expression.right)
                        return
                    }
                    left :: state.types[usize(expression.left)]
                    right :: state.types[usize(expression.right)]
                    if (left.kind == .invalid or right.kind == .invalid) return
                    if (pointer_addition(state, id)) {
                        if (right.kind != .usize or right.nominal != ast.NodeId(maxval!(u32))) {
                            try fail(state, id, .invalid_operand, expression.span)
                        }
                        return
                    }
                    if ((expression.operator == .equal or expression.operator == .not_equal)
                        and ((left.kind == .optional and right.kind == .null) or (left.kind == .null and right.kind == .optional))) return
                    if ((expression.operator == .equal or expression.operator == .not_equal)
                        and (left.kind == .bool or left.kind == .enumeration or left.kind == .pointer)
                        and (assignable_type(state, left, right) or assignable_type(state, right, left))) return
                    if (!numeric_kind(left.kind) or !numeric_kind(right.kind) or !same_type(state, left, right)) {
                        try fail(state, id, .invalid_operand, expression.span)
                    } else if (expression.operator == .divide and left.kind != .float) {
                        try fail(state, id, .integer_division, expression.span)
                    }
                }
                .range: {
                    if (state.cells[usize(id)].match_pattern) return
                    expression :: ast.range_expr(tree, id)
                    start_type :: state.types[usize(expression.start)]
                    end_type :: state.types[usize(expression.end)]
                    family TypeKind :: if (integer_kind(start_type.kind)) start_type.kind
                        else if (integer_kind(end_type.kind)) end_type.kind else .int
                    if (start_type.kind != .invalid and (!integer_kind(start_type.kind) or start_type.kind != family)) {
                        try fail(state, expression.start, .invalid_range_bound, ast.node_span(tree, expression.start))
                    }
                    if (end_type.kind != .invalid and (!integer_kind(end_type.kind) or end_type.kind != family)) {
                        try fail(state, expression.end, .invalid_range_bound, ast.node_span(tree, expression.end))
                    }
                }
                .array_literal: {
                    actual :: state.types[usize(id)]
                    if (actual.kind != .array) return
                    element :: state.arrays.items[usize(actual.array_type)].element
                    for 0..ast.array_element_count(tree, id) |i| {
                        child :: ast.array_element(tree, id, i)
                        if (element.kind == .void or element.kind == .range) {
                            try fail(state, child, .invalid_array_element_type, ast.node_span(tree, child))
                        } else {
                            try compatible(state, child, element)
                        }
                    }
                    if (array_cells(state, actual) == null) try fail(state, id, .array_size_overflow, ast.node_span(tree, id))
                }
                .record_literal: {
                    actual :: state.types[usize(id)]
                    if (actual.kind != .record) return
                    descriptor := state.records.items[usize(actual.record_type)]
                    if (state.variant_slots[usize(id)] != no_index and state.backings[usize(id)].kind == .record) {
                        descriptor = state.records.items[usize(state.backings[usize(id)].record_type)]
                    }
                    fields :: descriptor.fields
                    slot :: state.slots[usize(id)]
                    if (slot == no_index) return
                    values :: state.initializers.items[slot].fields
                    for fields |field, i| {
                        if (values[i] != ast.NodeId(maxval!(u32))) try compatible(state, values[i], field.type)
                    }
                    if (array_cells(state, actual) == null) try fail(state, id, .array_size_overflow, ast.node_span(tree, id))
                }
                .index: {
                    view :: ast.index_expr(tree, id)
                    base :: state.types[usize(view.base)]
                    index :: state.types[usize(view.index)]
                    if (index.kind != .invalid and (index.kind != .usize or index.nominal != ast.NodeId(maxval!(u32)))) {
                        try fail(state, view.index, .invalid_index_type, ast.node_span(tree, view.index))
                    }
                    if (base.kind != .invalid and !indexable_type(state, base)) {
                        try fail(state, id, .not_indexable, ast.node_span(tree, view.base))
                    }
                }
                .call: try validate_call(state, id)
                .builtin_call: _ = try infer_builtin(state, id, true)
                .slice: {
                    view :: ast.slice_expr(tree, id)
                    if (view.start) |node| try compatible(state, node, Type{ kind = .usize })
                    if (view.end) |node| try compatible(state, node, Type{ kind = .usize })
                }
                else: {}
            }
        }
        else: {}
    }
}

@hide:file
validate_call proc(state @mut State, id ast.NodeId) void ! (mem.AllocError | diagnostics.CapacityError) {
    tree :: state.tree
    expression :: ast.call_expr(tree, id)
    if (state.backings[usize(id)].kind != .none) {
        try validate_constructor(state, id)
        return
    }
    if (conversion_kind(state, id) != .none) {
        if (ast.call_arg_count(tree, id) != 1) {
            try fail(state, id, .argument_count_mismatch, expression.span)
        }
        for 0..ast.call_arg_count(tree, id) |i| {
            argument :: ast.call_arg(tree, id, i)
            actual :: state.types[usize(argument)]
            allowed_enum :: (
                actual.kind == .enumeration
                and state.enums.items[usize(actual.enum_type)].explicit_backing
            )
            backing :: immediate_backing(state, actual)
            if (actual.kind != .invalid
                and (!numeric_kind(backing.kind) and !allowed_enum
                    or backing.nominal != ast.NodeId(maxval!(u32)))) {
                try fail(state, argument, .invalid_operand, ast.node_span(tree, argument))
            }
        }
        return
    }
    callee :: state.types[usize(expression.callee)]
    signature :: group_type(state, expression.callee)
    if (signature.function == ast.NodeId(maxval!(u32))) {
        if (callee.kind != .invalid) {
            try fail(state, id, .not_callable, ast.node_span(tree, expression.callee))
        }
        return
    }
    parameter_count :: ast.function_param_count(tree, signature.function)
    if (parameter_count != ast.call_arg_count(tree, id)) {
        diagnostic :: try diagnostics.add(state.diagnostics, .argument_count_mismatch, expression.span)
        if (callee.kind != .invalid) state.types[usize(id)] = invalid_type(diagnostic)
    }
    for (0..ast.call_arg_count(tree, id)) |i| {
        if (i >= parameter_count) continue
        parameter :: ast.function_param(tree, signature.function, i)
        try compatible(state, ast.call_arg(tree, id, i), state.types[usize(parameter)])
    }
}


@hide:file
block_falls_through proc(state @State, id ast.NodeId) bool {
    tree :: state.tree
    for (0..ast.block_statement_count(tree, id)) |i| {
        statement :: ast.block_statement(tree, id, i)
        kind :: ast.stmt_kind(tree, statement)
        source :: if (kind == .expression) ast.statement_expr(tree, statement) else statement
        if (state.types[usize(source)].kind == .invalid) return false
        match kind {
            .return_stmt, .break_stmt, .continue_stmt, .invalid: return false
            .block_stmt: if (!block_falls_through(state, ast.statement_block(tree, statement))) return false
            .if_stmt: {
                conditional :: ast.if_stmt(tree, statement)
                then_falls :: block_falls_through(state, conditional.then_block)
                if (conditional.else_block) |other| {
                    if (!then_falls and !block_falls_through(state, other)) return false
                }
            }
            .expression: {
                if (ast.expr_kind(tree, source) == .match_expr and state.exhaustive[usize(source)]) {
                    falls := false
                    for 0..ast.match_arm_count(tree, source) |j| {
                        arm :: ast.match_arm_view(tree, ast.match_arm(tree, source, j))
                        if (arm.expression or block_falls_through(state, arm.body)) falls = true
                    }
                    if (!falls) return false
                }
            }
            else: {}
        }
    }
    return true
}

@hide:file
ConstantInteger :: struct {
    magnitude u64
    negative bool = false
}

@hide:file
constant_integer proc(state @mut State, id ast.NodeId) ?ConstantInteger {
    return evaluate_integer(state, id, false)
}

@hide:file
evaluate_integer proc(state @mut State, id ast.NodeId, allow_local bool) ?ConstantInteger {
    if (state.cells[usize(id)].constant_visiting) return null
    state.cells[usize(id)].constant_visiting = true
    defer state.cells[usize(id)].constant_visiting = false
    match ast.expr_kind(state.tree, id) {
        .typed_constant: return evaluate_integer(state, ast.typed_constant(state.tree, id).value, allow_local)
        .literal_int: {
            text :: ast.literal_text(state.tree, id)
            value := u64(0)
            for text |byte| {
                if (byte < '0' or byte > '9') return null
                digit :: u64(byte - '0')
                if (value > divtrunc!(maxval!(u64) - digit, u64(10))) return null
                value = value * 10 + digit
            }
            return ConstantInteger{ magnitude = value }
        }
        .identifier, .selection: {
            if (state.backings[usize(id)].kind == .enumeration and state.slots[usize(id)] != no_index) {
                type :: state.backings[usize(id)]
                member :: state.enums.items[usize(type.enum_type)].members[state.slots[usize(id)]]
                return ConstantInteger{ magnitude = member.magnitude, negative = member.negative }
            }
            binding :: sema.binding(state.resolution, id)
            if (binding.kind != .declaration) return null
            target :: binding.data.declaration
            if (!state.cells[usize(target)].count_declaration
                and (!allow_local or !state.cells[usize(target)].local)) return null
            declaration :: ast.statement_decl(state.tree, target)
            if (declaration.mutability != .constant) return null
            if (declaration.type) |annotation| {
                type_binding :: sema.binding(state.resolution, annotation)
                if (!integer_kind(state.types[usize(annotation)].kind)
                    and (type_binding.kind != .builtin or !integer_kind(builtin_kind(type_binding.data.builtin)))) return null
            }
            return evaluate_integer(state, declaration.initializer, allow_local)
        }
        .call: {
            if (ast.call_arg_count(state.tree, id) != 1) return null
            destination :: state.cells[usize(id)].type
            if (!integer_kind(destination.kind)) return null
            if (evaluate_integer(state, ast.call_arg(state.tree, id, 0), allow_local)) |value| {
                if (integer_fits(value, destination.kind)) return value
            }
            return null
        }
        .unary: {
            view :: ast.unary_expr(state.tree, id)
            if (view.operator != .negate) return null
            if (evaluate_integer(state, view.operand, allow_local)) |value| {
                return ConstantInteger{ magnitude = value.magnitude, negative = value.magnitude != 0 and !value.negative }
            }
            return null
        }
        .binary: {
            view :: ast.binary_expr(state.tree, id)
            left := ConstantInteger{ magnitude = 0 }
            right := ConstantInteger{ magnitude = 0 }
            if (evaluate_integer(state, view.left, allow_local)) |value| left = value else return null
            if (evaluate_integer(state, view.right, allow_local)) |value| right = value else return null
            if (view.operator == .multiply) {
                if (right.magnitude != 0 and left.magnitude > divtrunc!(maxval!(u64), right.magnitude)) return null
                magnitude :: left.magnitude * right.magnitude
                return ConstantInteger{ magnitude = magnitude, negative = magnitude != 0 and left.negative != right.negative }
            }
            if (view.operator != .add and view.operator != .subtract) return null
            if (view.operator == .subtract and right.magnitude != 0) right.negative = !right.negative
            if (left.negative == right.negative) {
                if (left.magnitude > maxval!(u64) - right.magnitude) return null
                return ConstantInteger{ magnitude = left.magnitude + right.magnitude, negative = left.negative }
            }
            if (left.magnitude < right.magnitude) {
                return ConstantInteger{ magnitude = right.magnitude - left.magnitude, negative = right.negative }
            }
            return ConstantInteger{ magnitude = left.magnitude - right.magnitude, negative = left.magnitude != right.magnitude and left.negative }
        }
        else: return null
    }
}

@hide:file
intern_pointer proc(state @mut State, descriptor PointerType) Type ! mem.AllocError {
    for state.pointers.items |existing, i| {
        if (existing.mutable == descriptor.mutable and existing.many == descriptor.many
            and same_type(state, existing.element, descriptor.element)) {
            return Type{ kind = .pointer, pointer_type = PointerId(i) }
        }
    }
    try arraylist.append(&state.pointers, descriptor)
    return Type{ kind = .pointer, pointer_type = PointerId(state.pointers.items.len - 1) }
}

@hide:file
check_pointer_type proc(state @mut State, id ast.NodeId) Type ! (mem.AllocError | diagnostics.CapacityError) {
    view :: ast.pointer_type(state.tree, id)
    state.pointer_depth += 1
    defer state.pointer_depth -= 1
    element :: try check_annotation(state, view.element, true)
    if (element.kind == .invalid) return element
    binding :: sema.binding(state.resolution, view.element)
    if (element.kind == .none or element.kind == .void or element.kind == .range
        or element.kind == .type_value
        or has_inferred_count(state, element)
        or (binding.kind == .builtin and (binding.data.builtin == .int or binding.data.builtin == .float))) {
        return invalid_type(try diagnostics.add(state.diagnostics, .invalid_pointer_type, ast.node_span(state.tree, id)))
    }
    return try intern_pointer(state, PointerType{ element = element, mutable = view.mutable, many = view.many })
}

@hide:file
check_function_type proc(state @mut State, id ast.NodeId) Type ! (mem.AllocError | diagnostics.CapacityError) {
    cached := state.cells[usize(id)].type
    if (cached.kind == .type_value) cached.kind = cached.value_kind
    if (cached.kind != .none) return cached
    type := Type{ kind = .function, function = id }
    state.cells[usize(id)].type = type
    state.pointer_depth += 1
    defer state.pointer_depth -= 1
    result :: ast.callable_result(state.tree, id)
    result_type :: try check_annotation(state, result, true)
    if (result_type.kind == .invalid) type = result_type
    try depend(state, result, id)
    for 0..ast.function_param_count(state.tree, id) |i| {
        parameter :: ast.function_param(state.tree, id, i)
        annotation :: ast.param(state.tree, parameter).type
        parameter_type :: try check_annotation(state, annotation, false)
        state.cells[usize(parameter)].role = .annotation
        state.cells[usize(parameter)].type = parameter_type
        state.types[usize(parameter)] = parameter_type
        if (parameter_type.kind == .invalid and type.kind != .invalid) type = parameter_type
        try depend(state, annotation, parameter)
        try depend(state, parameter, id)
    }
    type.function = id
    state.cells[usize(id)].type = type
    return type
}

@hide:file
intern_array proc(state @mut State, descriptor ArrayType) Type ! mem.AllocError {
    for state.arrays.items |existing, i| {
        if (existing.kind == descriptor.kind and existing.len == descriptor.len and existing.mutable == descriptor.mutable
            and same_sentinel(existing.sentinel, descriptor.sentinel) and same_type(state, existing.element, descriptor.element)
            and same_type(state, existing.error_type, descriptor.error_type)) {
            return Type{ kind = descriptor.kind, array_type = ArrayId(i) }
        }
    }
    try arraylist.append(&state.arrays, descriptor)
    return Type{ kind = descriptor.kind, array_type = ArrayId(state.arrays.items.len - 1) }
}

@hide:file
check_container_type proc(state @mut State, id ast.NodeId) Type ! (mem.AllocError | diagnostics.CapacityError) {
    optional :: ast.expr_kind(state.tree, id) == .optional_type
    node :: if (optional) ast.type_operand(state.tree, id) else ast.slice_type(state.tree, id).element
    if (!optional) state.pointer_depth += 1
    child :: try check_annotation(state, node, false)
    if (!optional) state.pointer_depth -= 1
    if (child.kind == .invalid) return child
    if (child.kind == .void or child.kind == .anyopaque or child.kind == .range or has_inferred_count(state, child)) {
        return invalid_type(try diagnostics.add(state.diagnostics, .invalid_array_element_type, ast.node_span(state.tree, node)))
    }
    kind TypeKind :: if (optional) .optional else .slice
    descriptor := ArrayType{ kind = kind, element = child }
    if (!optional) {
        view :: ast.slice_type(state.tree, id)
        descriptor.mutable = view.mutable
        if (view.sentinel) |sentinel| {
            try collect_expression(state, sentinel)
            try demand(state, sentinel, child, .type_mismatch)
            if (constant_integer(state, sentinel)) |value| {
                if (!integer_kind(child.kind) or !integer_fits(value, child.kind)) {
                    return invalid_type(try diagnostics.add(state.diagnostics, .invalid_operand, ast.node_span(state.tree, sentinel)))
                }
                descriptor.sentinel = sentinel_bits(value)
            } else return invalid_type(try diagnostics.add(state.diagnostics, .invalid_operand, ast.node_span(state.tree, sentinel)))
        }
    }
    return try intern_array(state, descriptor)
}

@hide:file
c_abi_type proc(state @State, type Type) bool {
    if (type.kind == .optional) return state.arrays.items[usize(type.array_type)].element.kind == .pointer
    return integer_kind(type.kind) or type.kind == .float or type.kind == .bool or type.kind == .pointer or type.kind == .void or type.kind == .invalid
}

@hide:file
builtin_name proc(state @State, id ast.NodeId) []u8 {
    return ast.source_text(state.tree, ast.node_span(state.tree, ast.builtin_call(state.tree, id).name))
}

@hide:file
collect_builtin proc(state @mut State, id ast.NodeId) void ! (mem.AllocError | diagnostics.CapacityError) {
    name :: builtin_name(state, id)
    count :: ast.call_arg_count(state.tree, id)
    layout :: mem.eql(name, "sizeof") or mem.eql(name, "alignof")
    cast :: mem.eql(name, "ptrcast") or mem.eql(name, "constcast")
    for (0..count) |i| {
        argument :: ast.call_arg(state.tree, id, i)
        if (layout or (cast and count == 2 and i == 0)) {
            _ = try check_annotation(state, argument, true)
        } else try collect_expression(state, argument)
        try depend(state, argument, id)
    }
    if (layout) state.cells[usize(id)].type = Type{ kind = .usize }
    if (mem.eql(name, "memcopy") or mem.eql(name, "memset")) state.cells[usize(id)].type = Type{ kind = .void }
}

@hide:file
sequence_type proc(state @mut State, node ast.NodeId, defaults bool) ArrayType ! (mem.AllocError | diagnostics.CapacityError) {
    type := try infer_shape(state, node, defaults)
    if (type.kind == .pointer) {
        pointer :: state.pointers.items[usize(type.pointer_type)]
        if (pointer.many or pointer.element.kind != .array) return ArrayType{ element = Type{} }
        type = pointer.element
        descriptor := state.arrays.items[usize(type.array_type)]
        descriptor.mutable = descriptor.mutable and pointer.mutable
        return descriptor
    }
    if (type.kind == .array or type.kind == .slice) {
        descriptor := state.arrays.items[usize(type.array_type)]
        if (type.kind == .array) descriptor.mutable = descriptor.mutable and mutable_target(state, node, true)
        return descriptor
    }
    if (type.kind == .string) return ArrayType{ element = Type{ kind = .u8 }, kind = .slice, sentinel = 0 }
    return ArrayType{ element = Type{} }
}

@hide:file
infer_slice proc(state @mut State, id ast.NodeId, defaults bool) Type ! (mem.AllocError | diagnostics.CapacityError) {
    view :: ast.slice_expr(state.tree, id)
    base :: try infer_shape(state, view.base, defaults)
    descriptor := try sequence_type(state, view.base, defaults)
    if (base.kind == .pointer and state.pointers.items[usize(base.pointer_type)].many) {
        pointer :: state.pointers.items[usize(base.pointer_type)]
        descriptor = ArrayType{ element = pointer.element, mutable = pointer.mutable }
        if (view.end == null or pointer.element.kind == .anyopaque) {
            try fail(state, id, .invalid_operand, ast.node_span(state.tree, id))
            seed(state, id, state.types[usize(id)])
            return group_type(state, id)
        }
    }
    if (view.start) |node| try demand(state, node, Type{ kind = .usize }, .invalid_index_type)
    if (view.end) |node| try demand(state, node, Type{ kind = .usize }, .invalid_index_type)
    if (descriptor.element.kind == .none) {
        if (defaults and base.kind != .none and base.kind != .invalid) try fail(state, id, .not_indexable, ast.node_span(state.tree, view.base))
        return group_type(state, id)
    }
    descriptor.kind = .slice
    descriptor.len = 0
    descriptor.sentinel = null
    if (view.sentinel) |node| {
        try demand(state, node, descriptor.element, .invalid_operand)
        if (constant_integer(state, node)) |value| {
            if (!integer_kind(descriptor.element.kind) or !integer_fits(value, descriptor.element.kind)) {
                try fail(state, id, .invalid_operand, ast.node_span(state.tree, node))
            } else {
                descriptor.sentinel = sentinel_bits(value)
            }
        } else if (defaults) try fail(state, id, .invalid_operand, ast.node_span(state.tree, node))
    }
    type :: try intern_array(state, descriptor)
    seed(state, id, type)
    return group_type(state, id)
}

@hide:file
cast_pointer_type proc(state @State, type Type) Type {
    if (type.kind == .optional) return state.arrays.items[usize(type.array_type)].element
    return type
}

@hide:file
infer_builtin proc(state @mut State, id ast.NodeId, defaults bool) Type ! (mem.AllocError | diagnostics.CapacityError) {
    name :: builtin_name(state, id)
    count :: ast.call_arg_count(state.tree, id)
    span :: ast.node_span(state.tree, id)
    layout :: mem.eql(name, "sizeof") or mem.eql(name, "alignof")
    cast :: mem.eql(name, "ptrcast") or mem.eql(name, "constcast")
    memory :: mem.eql(name, "memcopy") or mem.eql(name, "memset")
    valid_count :: (layout and count == 1) or (cast and (count == 1 or count == 2)) or (memory and count == 2)
    if (!valid_count) {
        code diagnostics.Code :: if (layout or cast or memory) .argument_count_mismatch else .invalid_operand
        if (defaults) try fail(state, id, code, span)
        return group_type(state, id)
    }
    if (layout) return group_type(state, id)
    if (cast) {
        result := state.cells[root(state, usize(id))].expected
        if (count == 2) result = state.types[usize(ast.call_arg(state.tree, id, 0))]
        operand :: ast.call_arg(state.tree, id, count - 1)
        source :: try infer_shape(state, operand, defaults)
        if (result.kind == .none and mem.eql(name, "constcast")) {
            result = source
            if (source.kind == .slice) {
                descriptor := state.arrays.items[usize(source.array_type)]
                descriptor.mutable = true
                result = try intern_array(state, descriptor)
            } else if (source.kind == .pointer) {
                descriptor := state.pointers.items[usize(source.pointer_type)]
                descriptor.mutable = true
                result = try intern_pointer(state, descriptor)
            }
        }
        if (result.kind == .none) {
            if (defaults) try fail(state, id, .cannot_infer_type, span)
            return group_type(state, id)
        }
        a :: cast_pointer_type(state, source)
        b :: cast_pointer_type(state, result)
        allowed := false
        if (a.kind == .pointer and b.kind == .pointer) {
            left :: state.pointers.items[usize(a.pointer_type)]
            right :: state.pointers.items[usize(b.pointer_type)]
            if (mem.eql(name, "constcast")) allowed = left.many == right.many and same_type(state, left.element, right.element)
            else allowed = left.mutable or !right.mutable
            if (source.kind == .optional and result.kind != .optional) allowed = false
        } else if (a.kind == .slice and b.kind == .slice and mem.eql(name, "constcast")) {
            left :: state.arrays.items[usize(a.array_type)]
            right :: state.arrays.items[usize(b.array_type)]
            allowed = same_sentinel(left.sentinel, right.sentinel) and same_type(state, left.element, right.element)
        } else if (source.kind == .null and result.kind == .optional and b.kind == .pointer) allowed = true
        if (!allowed and source.kind != .none and source.kind != .invalid and defaults) {
            try fail(state, id, .invalid_operand, span)
            seed(state, id, state.types[usize(id)])
            return group_type(state, id)
        }
        seed(state, id, result)
        return group_type(state, id)
    }
    destination :: try sequence_type(state, ast.call_arg(state.tree, id, 0), defaults)
    if (mem.eql(name, "memset") and destination.element.kind != .none) {
        try demand(state, ast.call_arg(state.tree, id, 1), destination.element, .type_mismatch)
    }
    if (defaults) {
        if (!destination.mutable or destination.element.kind == .none) {
            try fail(state, id, .invalid_operand, span)
        } else if (mem.eql(name, "memcopy")) {
            source :: try sequence_type(state, ast.call_arg(state.tree, id, 1), defaults)
            if (!same_type(state, destination.element, source.element)) try fail(state, id, .type_mismatch, span)
        } else {
            argument :: ast.call_arg(state.tree, id, 1)
            actual :: try infer_shape(state, argument, defaults)
            if (actual.kind != .none and actual.kind != .invalid and !assignable_value(state, argument, actual, destination.element)) {
                try fail(state, argument, .type_mismatch, ast.node_span(state.tree, argument))
            }
        }
    }
    return group_type(state, id)
}

@hide:file
same_type proc(state @State, left, right Type) bool {
    if (left.kind != right.kind) return false
    if (left.nominal != right.nominal) return false
    if (left.kind == .enumeration) {
        if (left.enum_type == right.enum_type) return true
        if (!state.enums.items[usize(left.enum_type)].composed and !state.enums.items[usize(right.enum_type)].composed) return false
        return (
            error_subset(state.records.items, state.enums.items, left, right)
            and error_subset(state.records.items, state.enums.items, right, left)
        )
    }
    if (left.kind == .pointer) {
        a :: state.pointers.items[usize(left.pointer_type)]
        b :: state.pointers.items[usize(right.pointer_type)]
        return a.mutable == b.mutable and a.many == b.many and same_type(state, a.element, b.element)
    }
    if (left.kind == .type_value) {
        a := left
        b := right
        a.kind = a.value_kind
        b.kind = b.value_kind
        return same_type(state, a, b)
    }
    if (left.kind == .function) return same_signature(state, left.function, right.function)
    if (left.kind == .record) {
        if (left.record_type == right.record_type) return true
        a :: state.records.items[usize(left.record_type)]
        b :: state.records.items[usize(right.record_type)]
        if (a.composed or b.composed) return (
            error_subset(state.records.items, state.enums.items, left, right)
            and error_subset(state.records.items, state.enums.items, right, left)
        )
        if (a.is_union or b.is_union) return false
        if (a.declaration != ast.NodeId(maxval!(u32)) or b.declaration != ast.NodeId(maxval!(u32))
            or a.fields.len != b.fields.len) return false
        for a.fields |field, i| {
            other :: b.fields[i]
            if ((field.name == null) != (other.name == null)) return false
            if (field.name) |name| {
                if (ast.name_id(state.tree, name) != ast.name_id(state.tree, other.name?)) return false
            }
            if (!same_type(state, field.type, other.type)) return false
        }
        return true
    }
    if (left.kind != .array and left.kind != .slice and left.kind != .optional and left.kind != .fallible) return true
    a :: state.arrays.items[usize(left.array_type)]
    b :: state.arrays.items[usize(right.array_type)]
    return (
        a.len == b.len and a.mutable == b.mutable and same_sentinel(a.sentinel, b.sentinel)
        and same_type(state, a.element, b.element) and same_type(state, a.error_type, b.error_type)
    )
}

@hide:file
same_sentinel proc(left, right ?i64) bool {
    if (left) |a| {
        if (right) |b| return a == b
        return false
    }
    return right == null
}

@hide:file
sentinel_bits proc(value ConstantInteger) i64 {
    if (!value.negative) return ptrcast!(@i64, &value.magnitude)^
    if (value.magnitude == u64(maxval!(i64)) + 1) return minval!(i64)
    return -i64(value.magnitude)
}

@hide:file
array_cells proc(state @State, type Type) ?usize {
    if (type.kind == .void) return usize(0)
    if (type.kind == .fallible) {
        descriptor :: state.arrays.items[usize(type.array_type)]
        success := usize(0)
        failure := usize(0)
        if (array_cells(state, descriptor.element)) |count| success = count else return null
        if (array_cells(state, descriptor.error_type)) |count| failure = count else return null
        payload :: if (success > failure) success else failure
        if (payload == maxval!(usize)) return null
        return payload + 1
    }
    if (type.kind == .slice) return usize(2)
    if (type.kind == .optional) {
        child :: state.arrays.items[usize(type.array_type)].element
        if (child.kind == .pointer or child.kind == .function) return usize(1)
        if (array_cells(state, child)) |count| {
            if (count < maxval!(usize)) return count + 1
        }
        return null
    }
    if (type.kind == .record) {
        total := usize(0)
        descriptor :: state.records.items[usize(type.record_type)]
        for state.records.items[usize(type.record_type)].fields |field| {
            child := usize(0)
            if (array_cells(state, field.type)) |value| child = value else return null
            if (descriptor.is_union) {
                if (child > total) total = child
            } else {
                if (total > maxval!(usize) - child) return null
                total += child
            }
        }
        if (descriptor.tag_type.kind != .none) {
            if (total == maxval!(usize)) return null
            total += 1
        }
        return total
    }
    if (type.kind != .array) return usize(1)
    view :: state.arrays.items[usize(type.array_type)]
    if (view.len == no_index) return null
    child := usize(0)
    if (array_cells(state, view.element)) |value| child = value else return null
    if (child != 0 and view.len > divtrunc!(maxval!(usize), child)) return null
    return view.len * child
}

@hide:file
array_origin proc(state @mut State, id ast.NodeId) ast.NodeId {
    origin :: state.cells[root(state, usize(id))].literal
    if (origin != ast.NodeId(maxval!(u32)) and ast.expr_kind(state.tree, origin) == .array_literal) return origin
    if (state.cells[usize(id)].role == .expression and ast.expr_kind(state.tree, id) == .index) {
        base :: array_origin(state, ast.index_expr(state.tree, id).base)
        if (base != ast.NodeId(maxval!(u32)) and ast.array_element_count(state.tree, base) != 0) {
            return array_origin(state, ast.array_element(state.tree, base, 0))
        }
    }
    return ast.NodeId(maxval!(u32))
}

@hide:file
unify_elements proc(state @mut State, left, right ast.NodeId) void ! (mem.AllocError | diagnostics.CapacityError) {
    if (state.types[usize(left)].kind == .invalid or state.types[usize(right)].kind == .invalid) return
    a :: array_origin(state, left)
    b :: array_origin(state, right)
    if (a != ast.NodeId(maxval!(u32)) and b != ast.NodeId(maxval!(u32))) {
        count :: ast.array_element_count(state.tree, a)
        if (count != ast.array_element_count(state.tree, b)) return
        for (0..count) |i| try unify_elements(state, ast.array_element(state.tree, a, i), ast.array_element(state.tree, b, i))
        return
    }
    left_type :: group_type(state, left)
    right_type :: group_type(state, right)
    if (numeric_kind(left_type.kind)) try demand(state, right, left_type, .type_mismatch)
    if (numeric_kind(right_type.kind)) try demand(state, left, right_type, .type_mismatch)
    left_root :: root(state, usize(left))
    right_root :: root(state, usize(right))
    if (state.cells[left_root].numeric and state.cells[right_root].numeric) {
        try numeric_constraint(state, left, right, right)
    }
    if (left_type.kind == .array or left_type.kind == .record) try demand(state, right, left_type, .type_mismatch)
    if (right_type.kind == .array or right_type.kind == .record) try demand(state, left, right_type, .type_mismatch)
}

@hide:file
infer_shape proc(state @mut State, id ast.NodeId, defaults bool) Type ! (mem.AllocError | diagnostics.CapacityError) {
    index :: root(state, usize(id))
    if (state.cells[index].visiting) return state.cells[index].type
    if (state.cells[index].type.kind == .invalid) return state.cells[index].type
    state.cells[index].visiting = true
    defer state.cells[index].visiting = false
    if (state.cells[usize(id)].role == .expression) {
        kind :: ast.expr_kind(state.tree, id)
        if (declaration_reference(state.tree, id) and has_narrowing(state, id)) {
            narrowed :: try narrow_reference(state, id)
            if (narrowed.kind != .none) {
                seed(state, id, narrowed)
                return narrowed
            }
        }
        if (kind == .try_expr or kind == .catch_expr) return try infer_fallible_expression(state, id, defaults)
        if (kind == .builtin_call) return try infer_builtin(state, id, defaults)
        if (kind == .slice) return try infer_slice(state, id, defaults)
        if (kind == .unary and ast.unary_expr(state.tree, id).operator == .unwrap) {
            operand :: try infer_shape(state, ast.unary_expr(state.tree, id).operand, defaults)
            if (operand.kind == .optional) {
                child :: state.arrays.items[usize(operand.array_type)].element
                seed(state, id, child)
                return child
            }
            return group_type(state, id)
        }
    }
    if (state.cells[usize(id)].role == .expression and ast.expr_kind(state.tree, id) == .binary) {
        view :: ast.binary_expr(state.tree, id)
        if (view.operator == .add) {
            _ = try infer_shape(state, view.left, defaults)
            if (pointer_addition(state, id)) {
                type :: group_type(state, view.left)
                state.cells[index].numeric = false
                seed(state, id, type)
                try demand(state, view.right, Type{ kind = .usize }, .invalid_operand)
                return group_type(state, id)
            }
        }
    }
    if (state.cells[usize(id)].role == .expression and ast.expr_kind(state.tree, id) == .unary) {
        view :: ast.unary_expr(state.tree, id)
        if (view.operator == .address_of or view.operator == .dereference) {
            operand :: try infer_shape(state, view.operand, defaults)
            if (operand.kind == .none) return Type{}
            if (operand.kind == .invalid) {
                seed(state, id, operand)
                return operand
            }
            if (view.operator == .dereference) {
                if (operand.kind != .pointer) {
                    try fail(state, id, .invalid_dereference, view.span)
                    seed(state, id, state.types[usize(id)])
                    return group_type(state, id)
                }
                element :: state.pointers.items[usize(operand.pointer_type)].element
                if (element.kind == .anyopaque) {
                    try fail(state, id, .invalid_dereference, view.span)
                    seed(state, id, state.types[usize(id)])
                    return group_type(state, id)
                }
                seed(state, id, element)
                return element
            }
            mutable :: mutable_target(state, view.operand, true)
            expected :: state.cells[index].expected
            if (expected.kind == .slice and operand.kind == .array) {
                array :: state.arrays.items[usize(operand.array_type)]
                writable :: array.mutable and (mutable or ast.expr_kind(state.tree, view.operand) == .array_literal)
                type :: try intern_array(state, ArrayType{ kind = .slice, element = array.element, mutable = writable })
                seed(state, id, type)
                return type
            }
            many :: expected.kind == .pointer and state.pointers.items[usize(expected.pointer_type)].many
            type :: try intern_pointer(state, PointerType{ element = operand, mutable = mutable, many = many })
            seed(state, id, type)
            return type
        }
    }
    if (state.cells[usize(id)].role == .expression and ast.expr_kind(state.tree, id) == .match_expr) {
        return try infer_match(state, id, defaults)
    }
    if (state.cells[usize(id)].role == .expression and ast.expr_kind(state.tree, id) == .call) {
        destination :: conversion_kind(state, id)
        if (destination != .none) {
            seed(state, id, Type{ kind = destination })
            return group_type(state, id)
        }
        if (state.backings[usize(id)].kind == .none) {
            signature :: try infer_shape(state, ast.call_expr(state.tree, id).callee, defaults)
            if (signature.kind == .function) {
                seed(state, id, state.types[usize(ast.callable_result(state.tree, signature.function))])
                return group_type(state, id)
            }
        }
    }
    if (state.cells[usize(id)].role == .expression
        and ast.expr_kind(state.tree, id) == .selection
        and sema.binding(state.resolution, id).kind == .none) {
        view :: ast.selection_expr(state.tree, id)
        if (type_reference(state, view.base)) {
            enum_shape :: try check_annotation(state, view.base, false)
            if (enum_shape.kind == .enumeration) return try select_enum_member(state, id, view.member, enum_shape)
        }
        base := try infer_shape(state, view.base, defaults)
        if ((base.kind == .array or base.kind == .slice or base.kind == .string) and base.nominal == ast.NodeId(maxval!(u32))) {
            member :: ast.source_text(state.tree, ast.node_span(state.tree, view.member))
            if (mem.eql(member, "len")) {
                seed(state, id, Type{ kind = .usize })
                return group_type(state, id)
            }
            if (mem.eql(member, "ptr")) {
                element :: if (base.kind == .string) Type{ kind = .u8 } else state.arrays.items[usize(base.array_type)].element
                mutable :: (
                    base.kind != .string and state.arrays.items[usize(base.array_type)].mutable
                    and (base.kind == .slice or mutable_target(state, view.base, true))
                )
                type :: try intern_pointer(state, PointerType{ element = element, mutable = mutable, many = true })
                seed(state, id, type)
                return type
            }
        }
        if (base.kind == .pointer and base.nominal == ast.NodeId(maxval!(u32))) {
            pointer :: state.pointers.items[usize(base.pointer_type)]
            if (!pointer.many and pointer.element.kind == .array
                and ast.expr_kind(state.tree, view.member) == .identifier) {
                member :: ast.source_text(state.tree, ast.node_span(state.tree, view.member))
                if (mem.eql(member, "len")) {
                    type :: Type{ kind = .usize }
                    seed(state, id, type)
                    return type
                }
                if (mem.eql(member, "ptr")) {
                    array :: state.arrays.items[usize(pointer.element.array_type)]
                    type :: try intern_pointer(state, PointerType{
                        element = array.element, mutable = pointer.mutable and array.mutable, many = true,
                    })
                    seed(state, id, type)
                    return type
                }
            }
            if (!pointer.many or pointer.element.kind == .record) base = pointer.element
        }
        if (base.kind == .record and base.nominal == ast.NodeId(maxval!(u32))) {
            fields :: state.records.items[usize(base.record_type)].fields
            slot :: selected_field(state, fields, view.member)
            if (slot != no_index) {
                state.slots[usize(id)] = slot
                seed(state, id, fields[slot].type)
                return fields[slot].type
            }
            try fail(state, id, .unknown_field, ast.node_span(state.tree, view.member))
        } else if (base.kind == .invalid) {
            seed(state, id, base)
        } else if (base.kind != .none) {
            try fail(state, id, .not_record, ast.node_span(state.tree, view.base))
        }
        if (base.kind == .none) {
            origin :: state.cells[root(state, usize(view.base))].literal
            if (origin != ast.NodeId(maxval!(u32)) and ast.expr_kind(state.tree, origin) == .record_literal) {
                for 0..ast.record_field_count(state.tree, origin) |i| {
                    field :: ast.field(state.tree, ast.record_field(state.tree, origin, i))
                    matches := false
                    if (field.name) |name| {
                        matches = (
                            ast.expr_kind(state.tree, view.member) == .identifier
                            and ast.name_id(state.tree, name) == ast.name_id(state.tree, view.member)
                        )
                    } else if (constant_integer(state, view.member)) |ordinal| {
                        matches = !ordinal.negative and ordinal.magnitude == u64(i)
                    }
                    if (!matches) continue
                    child :: field.value?
                    if (state.cells[root(state, usize(child))].numeric) try numeric_constraint(state, id, child, id)
                    break
                }
            }
        }
        return group_type(state, id)
    }
    if (state.cells[usize(id)].role == .expression and declaration_reference(state.tree, id)) {
        binding :: sema.binding(state.resolution, id)
        if (binding.kind == .declaration) {
            target :: binding.data.declaration
            if (state.cells[usize(target)].role == .declaration and state.cells[usize(target)].fixed
                and has_inferred_count(state, state.cells[usize(target)].type)) {
                declaration :: ast.statement_decl(state.tree, target)
                actual :: try infer_shape(state, declaration.initializer, defaults)
                if (actual.kind == .array and !has_inferred_count(state, actual)) {
                    try specialize_annotation(state, declaration.type?, actual)
                    state.cells[usize(target)].type = state.types[usize(declaration.type?)]
                    seed(state, id, state.cells[usize(target)].type)
                }
            }
        }
    }
    literal :: state.cells[index].literal
    if (literal != ast.NodeId(maxval!(u32)) and ast.expr_kind(state.tree, literal) == .enum_literal) {
        return try infer_enum_literal(state, literal, state.cells[index].expected, defaults)
    }
    if (literal != ast.NodeId(maxval!(u32)) and ast.expr_kind(state.tree, literal) == .record_literal) {
        return try infer_record_literal(state, literal, index, defaults)
    }
    if (literal != ast.NodeId(maxval!(u32))) {
        len :: ast.array_element_count(state.tree, literal)
        expected :: state.cells[index].expected
        element := Type{}
        mutable := false
        if (expected.kind == .array) {
            view :: state.arrays.items[usize(expected.array_type)]
            element = view.element
            mutable = view.mutable
        }
        for 0..len |i| {
            child :: ast.array_element(state.tree, literal, i)
            actual :: try infer_shape(state, child, defaults)
            if (element.kind == .none and actual.kind != .none and actual.kind != .invalid) element = actual
            if (element.kind == .array and actual.kind == .array) element = try specialize_type(state, element, actual)
            if (element.kind != .none) try demand(state, child, element, .type_mismatch)
        }
        if (element.kind == .none and len == 0 and defaults) element = Type{ kind = .int }
        if (element.kind != .none) {
            type :: try intern_array(state, ArrayType{ element = element, len = len, mutable = mutable })
            state.cells[index].type = type
            return type
        }
        return Type{}
    }
    if (state.cells[usize(id)].role == .expression and ast.expr_kind(state.tree, id) == .index) {
        view :: ast.index_expr(state.tree, id)
        base := try infer_shape(state, view.base, defaults)
        if (base.kind == .pointer and base.nominal == ast.NodeId(maxval!(u32))) {
            pointer :: state.pointers.items[usize(base.pointer_type)]
            if (pointer.many) {
                seed(state, id, pointer.element)
                return pointer.element
            }
            base = pointer.element
        }
        if (base.kind == .string) {
            seed(state, id, Type{ kind = .u8 })
            return group_type(state, id)
        }
        if ((base.kind == .array or base.kind == .slice) and base.nominal == ast.NodeId(maxval!(u32))) {
            element :: state.arrays.items[usize(base.array_type)].element
            seed(state, id, element)
            return element
        }
        origin :: array_origin(state, view.base)
        if (origin != ast.NodeId(maxval!(u32)) and ast.array_element_count(state.tree, origin) != 0) {
            child :: ast.array_element(state.tree, origin, 0)
            child_root :: root(state, usize(child))
            if (state.cells[child_root].numeric) {
                try numeric_constraint(state, id, child, id)
            }
        }
    }
    return group_type(state, id)
}

@hide:file
prepare_optional_captures proc(state @mut State, defaults bool) void ! (mem.AllocError | diagnostics.CapacityError) {
    for 0..(state.cells.len) |i| {
        if (state.cells[i].role == .expression and ast.expr_kind(state.tree, ast.NodeId(i)) == .catch_expr) {
            _ = try infer_shape(state, ast.NodeId(i), defaults)
        }
    }
    for (0..(state.cells.len)) |i| {
        capture :: state.cells[i].capture
        if (capture == ast.NodeId(maxval!(u32)) or state.cells[i].role != .expression) continue
        if (state.cells[usize(capture)].role != .loop_capture) continue
        type :: try infer_shape(state, ast.NodeId(i), defaults)
        if (type.kind != .optional) continue
        child :: state.arrays.items[usize(type.array_type)].element
        seed(state, capture, child)
        for (0..(state.cells.len)) |j| {
            if (state.cells[j].role != .expression or !declaration_reference(state.tree, ast.NodeId(j))) continue
            binding :: sema.binding(state.resolution, ast.NodeId(j))
            if (binding.kind == .declaration and binding.data.declaration == capture
                and !has_narrowing(state, ast.NodeId(j))) seed(state, ast.NodeId(j), child)
        }
    }
}

@hide:file
prepare_shapes proc(state @mut State, assignment_values, defaults bool) void ! (mem.AllocError | diagnostics.CapacityError) {
    try prepare_optional_captures(state, defaults)
    for 0..(state.cells.len) |i| {
        if (state.cells[i].role != .expression or state.cells[i].assignment_value != assignment_values) continue
        id :: ast.NodeId(i)
        if (
            ast.expr_kind(state.tree, id) == .array_literal
            and state.cells[root(state, i)].expected.kind != .array
        ) {
            len :: ast.array_element_count(state.tree, id)
            for (usize(1)..len) |j| try unify_elements(state, ast.array_element(state.tree, id, 0), ast.array_element(state.tree, id, j))
        }
        _ = try infer_shape(state, id, defaults)
    }
}

@hide:file
apply_contexts proc(state @mut State, assignment_values, early bool) void ! (mem.AllocError | diagnostics.CapacityError) {
    tree :: state.tree
    if (!assignment_values) {
        for 0..(state.records.items.len) |i| {
            record :: state.records.items[i]
            for record.fields |field| {
                if (field.default) |value| try context_demand(state, value, field.type, .type_mismatch, early)
            }
        }
    }
    for 0..(state.cells.len) |i| {
        id :: ast.NodeId(i)
        if (state.cells[i].role == .expression and state.cells[i].assignment_value == assignment_values) {
            if (ast.expr_kind(tree, id) == .typed_constant) {
                value :: ast.typed_constant(tree, id)
                try context_demand(state, value.value, state.cells[i].type, .type_mismatch, early)
            }
            if (ast.expr_kind(tree, id) == .match_expr) _ = try infer_match(state, id, false)
            if (ast.expr_kind(tree, id) == .binary) {
                expression :: ast.binary_expr(tree, id)
                if (expression.operator == .equal or expression.operator == .not_equal) {
                    left :: try infer_shape(state, expression.left, false)
                    right :: try infer_shape(state, expression.right, false)
                    if (left.kind == .enumeration or left.kind == .bool) try demand(state, expression.right, left, .invalid_operand)
                    if (right.kind == .enumeration or right.kind == .bool) try demand(state, expression.left, right, .invalid_operand)
                }
            }
        }
        if (!assignment_values and state.cells[i].role == .declaration) {
            view :: ast.statement_decl(tree, id)
            if (view.type) |annotation| try context_demand(state, view.initializer, state.types[usize(annotation)], .type_mismatch, early)
        }
        if (!assignment_values and state.cells[i].role == .return_stmt) {
            if (ast.return_stmt(tree, id).value) |value| {
                try context_demand(state, value, state.types[usize(state.cells[i].return_annotation)], .return_type_mismatch, early)
            }
        }
        if (assignment_values and state.cells[i].role == .assignment_stmt) {
            view :: ast.assignment_stmt(tree, id)
            if (mutable_target(state, view.target, false)) try context_demand(state, view.value, state.types[usize(view.target)], .type_mismatch, early)
        }
        if (state.cells[i].role != .expression or state.cells[i].assignment_value != assignment_values or ast.expr_kind(tree, id) != .call) continue
        if (state.backings[i].kind != .none) {
            backing :: state.backings[i]
            if (ast.call_arg_count(tree, id) == 1
                and (backing.nominal != ast.NodeId(maxval!(u32)) or !numeric_kind(backing.kind))) {
                try context_demand(state, ast.call_arg(tree, id, 0), backing, .type_mismatch, early)
            }
            continue
        }
        if (conversion_kind(state, id) != .none) {
            for 0..ast.call_arg_count(tree, id) |j| {
                argument :: ast.call_arg(tree, id, j)
                if (constant_integer(state, argument)) |value| {
                    if (!value.negative and value.magnitude > u64(maxval!(i64))) {
                        state.cells[root(state, usize(argument))].conversion_unsigned = true
                    }
                }
            }
            continue
        }
        signature :: group_type(state, ast.call_expr(tree, id).callee)
        if (signature.function == ast.NodeId(maxval!(u32))) continue
        count :: ast.function_param_count(tree, signature.function)
        for 0..ast.call_arg_count(tree, id) |j| {
            if (j >= count) continue
            parameter :: ast.function_param(tree, signature.function, j)
            try context_demand(state, ast.call_arg(tree, id, j), state.cells[usize(parameter)].type, .type_mismatch, early)
        }
    }
}

@hide:file
context_demand proc(state @mut State, id ast.NodeId, expected Type, code diagnostics.Code, early bool) void ! (mem.AllocError | diagnostics.CapacityError) {
    if (early and expected.kind != .array and expected.kind != .record
        and expected.kind != .pointer and expected.kind != .slice and expected.kind != .optional and expected.kind != .fallible
        and expected.kind != .enumeration and !integer_kind(expected.kind)) return
    try demand(state, id, expected, code)
}

@hide:file
bound_family proc(state @mut State, id ast.NodeId) TypeKind {
    index :: root(state, usize(id))
    if (state.cells[index].type.kind != .none) return state.cells[index].type.kind
    if (state.cells[index].demand != .none) return state.cells[index].demand
    producer :: state.cells[index].producer
    if (producer == ast.NodeId(maxval!(u32)) or state.cells[index].visiting) return .none
    state.cells[index].visiting = true
    defer state.cells[index].visiting = false
    if (ast.expr_kind(state.tree, producer) == .unary) return bound_family(state, ast.unary_expr(state.tree, producer).operand)
    view :: ast.binary_expr(state.tree, producer)
    left :: bound_family(state, view.left)
    right :: bound_family(state, view.right)
    if (left == .float or right == .float) return .float
    if (integer_kind(left)) return left
    if (integer_kind(right)) return right
    return .none
}

@hide:file
prepare_ranges proc(state @mut State, assignment_values, constrain bool) void ! (mem.AllocError | diagnostics.CapacityError) {
    tree :: state.tree
    for 0..(state.cells.len) |i| {
        id :: ast.NodeId(i)
        if (state.cells[i].match_pattern) continue
        if (state.cells[i].role != .expression or state.cells[i].assignment_value != assignment_values or ast.expr_kind(tree, id) != .range) continue
        view :: ast.range_expr(tree, id)
        left :: bound_family(state, view.start)
        right :: bound_family(state, view.end)
        family TypeKind :: if (integer_kind(left)) left else if (integer_kind(right)) right else .int
        if (constrain) {
            try range_bound_context(state, view.start, family)
            try range_bound_context(state, view.end, family)
        }
        if (group_type(state, id).kind != .invalid) {
            seed(state, id, Type{ kind = .range, range_element = family })
            state.types[i] = group_type(state, id)
        }
        capture :: state.cells[i].capture
        if (capture != ast.NodeId(maxval!(u32)) and state.cells[usize(capture)].type.kind != .invalid) {
            seed(state, capture, Type{ kind = family })
        }
    }
    for 0..(state.cells.len) |i| {
        id :: ast.NodeId(i)
        if (state.cells[i].role != .expression
            or state.cells[i].assignment_value
            or !declaration_reference(tree, id)
        ) continue
        binding :: sema.binding(state.resolution, id)
        if (binding.kind == .declaration and state.cells[usize(binding.data.declaration)].role == .loop_capture
            and !has_narrowing(state, id)) {
            seed(state, id, group_type(state, binding.data.declaration))
        }
    }
}

@hide:file
has_inferred_count proc(state @State, type Type) bool {
    if (type.kind != .array) return false
    view :: state.arrays.items[usize(type.array_type)]
    return view.len == no_index or has_inferred_count(state, view.element)
}

@hide:file
specialize_type proc(state @mut State, expected, actual Type) Type ! mem.AllocError {
    if (expected.kind != .array or actual.kind != .array) return expected
    view := state.arrays.items[usize(expected.array_type)]
    source :: state.arrays.items[usize(actual.array_type)]
    if (view.len == no_index) view.len = source.len
    view.element = try specialize_type(state, view.element, source.element)
    return try intern_array(state, view)
}

@hide:file
specialize_annotation proc(state @mut State, id ast.NodeId, actual Type) void ! mem.AllocError {
    expected :: try specialize_type(state, state.types[usize(id)], actual)
    state.types[usize(id)] = expected
    state.cells[usize(id)].type = expected
    if (expected.kind == .array and ast.expr_kind(state.tree, id) == .array_type) {
        try specialize_annotation(state, ast.array_type(state.tree, id).element, state.arrays.items[usize(expected.array_type)].element)
    }
}

@hide:file
specialize_annotations proc(state @mut State) void ! (mem.AllocError | diagnostics.CapacityError) {
    for 0..(state.cells.len) |i| {
        if (state.cells[i].role != .declaration) continue
        view :: ast.statement_decl(state.tree, ast.NodeId(i))
        if (view.type) |annotation| {
            actual :: try infer_shape(state, view.initializer, true)
            try specialize_annotation(state, annotation, actual)
            if (state.cells[i].type.kind != .invalid) state.cells[i].type = state.types[usize(annotation)]
        }
    }
    for 0..(state.cells.len) |i| {
        if (state.cells[i].role != .annotation or state.types[i].kind != .array) continue
        if (has_inferred_count(state, state.types[i])) {
            try fail(state, ast.NodeId(i), .invalid_array_length, ast.node_span(state.tree, ast.NodeId(i)))
            state.cells[i].type = state.types[i]
        } else if (array_cells(state, state.types[i]) == null) {
            try fail(state, ast.NodeId(i), .array_size_overflow, ast.node_span(state.tree, ast.NodeId(i)))
            state.cells[i].type = state.types[i]
        }
    }
    for 0..(state.cells.len) |i| {
        id :: ast.NodeId(i)
        if (state.cells[i].role != .expression
            or state.cells[i].assignment_value
            or !declaration_reference(state.tree, id)
        ) continue
        binding :: sema.binding(state.resolution, id)
        if (binding.kind == .declaration and state.cells[usize(binding.data.declaration)].fixed
            and !has_narrowing(state, id)) {
            seed(state, id, state.cells[usize(binding.data.declaration)].type)
        }
    }
}

@hide:file
named_field proc(tree @ast.Tree, fields []RecordField, name ast.NodeId) usize {
    for fields |field, i| {
        if (field.name) |existing| {
            if (ast.name_id(tree, existing) == ast.name_id(tree, name)) return i
        }
    }
    return no_index
}

@hide:file
selected_field proc(state @State, fields []RecordField, member ast.NodeId) usize {
    if (ast.expr_kind(state.tree, member) == .identifier) return named_field(state.tree, fields, member)
    value := usize(0)
    for ast.source_text(state.tree, ast.node_span(state.tree, member)) |byte| {
        if (byte < '0' or byte > '9') return no_index
        digit :: usize(byte - '0')
        if (value > divtrunc!(maxval!(usize) - digit, usize(10))) return no_index
        value = value * 10 + digit
    }
    if (value >= fields.len or fields[value].name != null) return no_index
    return value
}

@hide:file
intern_record proc(state @mut State, declaration ast.NodeId, fields []mut RecordField) Type ! mem.AllocError {
    for state.records.items |existing, i| {
        if (existing.is_union or existing.declaration != declaration or existing.fields.len != fields.len) continue
        equal := true
        same_defaults := true
        for fields |field, j| {
            slot := j
            if (field.name) |name| slot = named_field(state.tree, existing.fields, name)
            if (slot == no_index or (field.name == null and existing.fields[slot].name != null)
                or !same_type(state, field.type, existing.fields[slot].type)) {
                equal = false
                break
            }
            other_default :: existing.fields[slot].default
            if ((field.default == null) != (other_default == null)) {
                same_defaults = false
            } else if (field.default) |value| {
                if (value != other_default?) same_defaults = false
            }
        }
        if (equal and same_defaults) {
            mem.free(state.records.allocator, fields)
            return Type{ kind = .record, record_type = RecordId(i) }
        }
        if (equal) {
            for existing.fields |field, j| {
                if (field.name) |name| {
                    slot :: named_field(state.tree, fields, name)
                    saved :: fields[j]
                    fields[j] = fields[slot]
                    fields[slot] = saved
                }
            }
        }
    }
    try arraylist.append(&state.records, RecordType{ declaration = declaration, fields = fields })
    return Type{ kind = .record, record_type = RecordId(state.records.items.len - 1) }
}

@hide:file
check_record proc(state @mut State, id ast.NodeId, nominal bool) Type ! (mem.AllocError | diagnostics.CapacityError) {
    cached := state.cells[usize(id)].type
    if (cached.kind == .invalid) return cached
    if (!state.cells[usize(id)].record_checking and (cached.kind == .record or cached.kind == .type_value)) {
        cached.kind = .record
        return cached
    }
    if (state.cells[usize(id)].record_checking) {
        if (cached.kind == .record and state.pointer_depth > state.cells[usize(id)].record_pointer_depth) {
            cached.kind = .record
            return cached
        }
        type :: invalid_type(try diagnostics.add(state.diagnostics, .recursive_record, ast.node_span(state.tree, id)))
        state.cells[usize(id)].type = type
        return type
    }
    state.cells[usize(id)].record_checking = true
    defer state.cells[usize(id)].record_checking = false
    state.cells[usize(id)].record_pointer_depth = state.pointer_depth
    record_id := no_record
    result_type := Type{}
    if (nominal) {
        record_id = RecordId(state.records.items.len)
        empty :: try mem.alloc(RecordField, state.records.allocator, 0)
        arraylist.append(&state.records, RecordType{ declaration = id, fields = empty }) catch |err| {
            mem.free(state.records.allocator, empty)
            return err
        }
        result_type = Type{ kind = .record, record_type = record_id }
        state.cells[usize(id)].type = result_type
    }
    count :: ast.record_field_count(state.tree, id)
    fields :: try mem.alloc(RecordField, state.records.allocator, count)
    owned := true
    defer {
        if (owned) mem.free(state.records.allocator, fields)
    }
    failure := Type{}
    for 0..count |i| {
        node :: ast.record_field(state.tree, id, i)
        view :: ast.field(state.tree, node)
        type := try check_annotation(state, view.type?, false)
        if (type.kind == .void or type.kind == .range or type.kind == .type_value or type.kind == .none) {
            type = invalid_type(try diagnostics.add(state.diagnostics, .invalid_record_field_type, view.span))
        }
        if (view.name) |name| {
            if (named_field(state.tree, fields[0..i], name) != no_index) {
                type = invalid_type(try diagnostics.add(state.diagnostics, .duplicate_field, ast.node_span(state.tree, name)))
            }
        }
        fields[i] = RecordField{ name = view.name, type = type, default = view.value }
        if (type.kind == .invalid) failure = type
    }
    if (failure.kind == .invalid) {
        state.cells[usize(id)].type = failure
        return failure
    }
    if (nominal) {
        mem.free(state.records.allocator, state.records.items[usize(record_id)].fields)
        state.records.items[usize(record_id)].fields = fields
    } else result_type = try intern_record(state, ast.NodeId(maxval!(u32)), fields)
    owned = false
    state.cells[usize(id)].type = result_type
    state.cells[usize(id)].record_checking = false
    saved_assignment :: state.collecting_assignment
    state.collecting_assignment = false
    defer state.collecting_assignment = saved_assignment
    for 0..count |i| {
        if (ast.field(state.tree, ast.record_field(state.tree, id, i)).value) |value| {
            try collect_expression(state, value)
        }
    }
    return result_type
}

@hide:file
infer_record_literal proc(state @mut State, literal ast.NodeId, index usize, defaults bool) Type ! (mem.AllocError | diagnostics.CapacityError) {
    if (state.types[usize(literal)].kind == .invalid) return state.types[usize(literal)]
    count :: ast.record_field_count(state.tree, literal)
    expected := state.cells[index].expected
    if (expected.kind == .none and state.cells[index].type.kind == .record) expected = state.cells[index].type
    if (ast.record_literal(state.tree, literal).type) |annotation| {
        if (ast.expr_kind(state.tree, annotation) == .enum_literal) {
            return try infer_variant_payload(state, literal, expected, defaults)
        }
    }
    if (expected.kind == .invalid) {
        seed(state, literal, expected)
        return expected
    }
    if (expected.nominal != ast.NodeId(maxval!(u32))) {
        try fail(state, literal, .type_mismatch, ast.node_span(state.tree, literal))
        return state.types[usize(literal)]
    }
    if (expected.kind != .none and expected.kind != .record) {
        try fail(state, literal, .expected_type, ast.node_span(state.tree, literal))
        return state.types[usize(literal)]
    }
    if (expected.kind == .record and state.records.items[usize(expected.record_type)].is_union and count != 1) {
        try fail(state, literal, .union_initializer_count, ast.node_span(state.tree, literal))
        return state.types[usize(literal)]
    }
    if (expected.kind == .none) {
        ready := true
        for 0..count |i| {
            value :: ast.field(state.tree, ast.record_field(state.tree, literal, i)).value?
            actual :: try infer_shape(state, value, defaults)
            if (actual.kind == .none) ready = false
            if (actual.kind == .invalid) {
                seed(state, literal, actual)
                return actual
            }
        }
        if (!ready) return Type{}
        fields :: try mem.alloc(RecordField, state.records.allocator, count)
        errdefer mem.free(state.records.allocator, fields)
        for 0..count |i| {
            view :: ast.field(state.tree, ast.record_field(state.tree, literal, i))
            type := group_type(state, view.value?)
            if (type.kind == .void or type.kind == .type_value or type.kind == .range) {
                try fail(state, literal, .invalid_record_field_type, view.span)
                mem.free(state.records.allocator, fields)
                return state.types[usize(literal)]
            }
            if (view.name) |name| {
                if (named_field(state.tree, fields[0..i], name) != no_index) {
                    try fail(state, literal, .duplicate_field, ast.node_span(state.tree, name))
                    mem.free(state.records.allocator, fields)
                    return state.types[usize(literal)]
                }
            }
            fields[i] = RecordField{ name = view.name, type = type, default = null }
        }
        expected = try intern_record(state, ast.NodeId(maxval!(u32)), fields)
    }
    fields :: state.records.items[usize(expected.record_type)].fields
    slot := state.slots[usize(literal)]
    fresh :: slot == no_index
    if (slot == no_index) {
        values :: try mem.alloc(ast.NodeId, state.initializers.allocator, fields.len)
        errdefer mem.free(state.initializers.allocator, values)
        try arraylist.append(&state.initializers, RecordInitializer{ fields = values })
        slot = state.initializers.items.len - 1
        state.slots[usize(literal)] = slot
    }
    values :: state.initializers.items[slot].fields
    if (values.len != fields.len) {
        try fail(state, literal, .type_mismatch, ast.node_span(state.tree, literal))
        return state.types[usize(literal)]
    }
    mem.set(values, ast.NodeId(maxval!(u32)))
    for 0..count |i| {
        node :: ast.record_field(state.tree, literal, i)
        view :: ast.field(state.tree, node)
        if (state.records.items[usize(expected.record_type)].is_union and view.name == null) {
            try fail(state, literal, .unknown_field, view.span)
            continue
        }
        field_slot := i
        if (view.name) |name| field_slot = named_field(state.tree, fields, name)
        if (field_slot >= fields.len) {
            code :: if (view.name != null) diagnostics.Code.unknown_field else diagnostics.Code.tuple_arity_mismatch
            try fail(state, literal, code, view.span)
            continue
        }
        if (values[field_slot] != ast.NodeId(maxval!(u32))) {
            try fail(state, literal, .duplicate_field, view.span)
            continue
        }
        values[field_slot] = view.value?
        if (state.records.items[usize(expected.record_type)].is_union) {
            state.variant_slots[usize(literal)] = field_slot
        }
        try demand(state, view.value?, fields[field_slot].type, .type_mismatch)
        _ = try infer_shape(state, view.value?, defaults)
    }
    for fields |field, i| {
        if (state.records.items[usize(expected.record_type)].is_union) continue
        if (values[i] != ast.NodeId(maxval!(u32))) continue
        if (field.default) |value| {
            values[i] = value
            if (fresh) try depend(state, value, literal)
        } else {
            code :: if (field.name == null) diagnostics.Code.tuple_arity_mismatch else diagnostics.Code.missing_field
            try fail(state, literal, code, ast.node_span(state.tree, literal))
        }
    }
    if (state.types[usize(literal)].kind == .invalid) return state.types[usize(literal)]
    state.cells[index].type = expected
    return expected
}

@hide:file
type_syntax proc(kind ast.ExprKind) bool {
    return (
        kind == .record_type or kind == .union_type or kind == .enum_type
        or kind == .distinct_type or kind == .alias_expr
        or kind == .pointer_type or kind == .function_type or kind == .slice_type or kind == .optional_type
        or kind == .fallible_type or kind == .sum_type
    )
}

@hide:file
type_reference proc(state @State, id ast.NodeId) bool {
    kind :: ast.expr_kind(state.tree, id)
    if (type_syntax(kind) or kind == .array_type) return true
    binding :: sema.binding(state.resolution, id)
    if (binding.kind == .builtin) return true
    if (binding.kind != .declaration) return false
    target :: binding.data.declaration
    role :: state.cells[usize(target)].role
    if (role == .parameter or role == .loop_capture) return false
    return (
        ast.decl_kind(state.tree, target) == .statement
        and type_syntax(ast.expr_kind(state.tree, ast.statement_decl(state.tree, target).initializer))
    )
}

@hide:file
immediate_backing proc(state @State, type Type) Type {
    if (type.nominal == ast.NodeId(maxval!(u32))) return type
    return state.backings[usize(type.nominal)]
}

@hide:file
check_type_expression proc(state @mut State, id ast.NodeId, nominal bool) Type ! (mem.AllocError | diagnostics.CapacityError) {
    kind :: ast.expr_kind(state.tree, id)
    if (kind == .record_type) return try check_record(state, id, nominal)
    if (kind == .pointer_type) return try check_pointer_type(state, id)
    if (kind == .function_type) return try check_function_type(state, id)
    if (kind == .slice_type or kind == .optional_type) return try check_container_type(state, id)
    if (kind == .fallible_type) return try check_fallible_type(state, id)
    if (kind == .sum_type) return try check_sum_type(state, id)
    if (kind == .union_type) {
        type :: try check_union(state, id, nominal)
        state.cells[usize(id)].type = type
        return type
    }
    cached := state.cells[usize(id)].type
    if (cached.kind == .type_value) {
        cached.kind = cached.value_kind
        return cached
    }
    if (cached.kind != .none) return cached
    if (kind == .enum_type) {
        type :: try check_enum(state, id)
        state.cells[usize(id)].type = type
        return type
    }
    if (state.cells[usize(id)].record_checking) {
        return invalid_type(try diagnostics.add(state.diagnostics, .recursive_record, ast.node_span(state.tree, id)))
    }
    state.cells[usize(id)].record_checking = true
    defer state.cells[usize(id)].record_checking = false
    type := try check_annotation(state, ast.type_operand(state.tree, id), true)
    operand_binding :: sema.binding(state.resolution, ast.type_operand(state.tree, id))
    constraint :: (
        operand_binding.kind == .builtin
        and (operand_binding.data.builtin == .int or operand_binding.data.builtin == .float)
    )
    if (kind == .distinct_type and type.kind != .invalid) {
        if (type.kind == .none or type.kind == .void or type.kind == .range or type.kind == .type_value
            or type.kind == .function or has_inferred_count(state, type) or constraint) {
            type = invalid_type(try diagnostics.add(state.diagnostics, .invalid_distinct_backing, ast.node_span(state.tree, id)))
        } else {
            state.backings[usize(id)] = type
            type.nominal = id
        }
    }
    state.cells[usize(id)].type = type
    return type
}

@hide:file
integer_fits proc(value ConstantInteger, kind TypeKind) bool {
    bits := u32(64)
    match kind {
        .u8, .i8: bits = 8
        .u16, .i16: bits = 16
        .u32, .i32: bits = 32
        else: {}
    }
    limit := maxval!(u64)
    if (unsigned_kind(kind)) {
        if (value.negative) return false
        if (bits < 64) limit = (u64(1) << bits) - 1
    } else {
        limit = u64(1) << (bits - 1)
        if (!value.negative) limit -= 1
    }
    return value.magnitude <= limit
}

@hide:file
enum_member_slot proc(state @State, descriptor EnumType, name ast.NodeId) usize {
    for descriptor.members |member, i| {
        if (ast.name_id(state.tree, member.name) == ast.name_id(state.tree, name)) return i
    }
    return no_index
}

@hide:file
check_enum proc(state @mut State, id ast.NodeId) Type ! (mem.AllocError | diagnostics.CapacityError) {
    cached := state.cells[usize(id)].type
    if (cached.kind == .type_value) cached.kind = cached.value_kind
    if (cached.kind != .none) return cached
    if (state.cells[usize(id)].record_checking) {
        return invalid_type(try diagnostics.add(state.diagnostics, .invalid_enum_backing, ast.node_span(state.tree, id)))
    }
    state.cells[usize(id)].record_checking = true
    defer state.cells[usize(id)].record_checking = false
    backing := Type{ kind = .u16 }
    explicit := false
    if (ast.enum_type(state.tree, id).backing) |annotation| {
        backing = try check_annotation(state, annotation, false)
        explicit = true
        if (backing.kind == .invalid) return backing
        binding :: sema.binding(state.resolution, annotation)
        if (binding.kind == .builtin and binding.data.builtin == .int) {
            return invalid_type(try diagnostics.add(state.diagnostics, .invalid_enum_backing, ast.node_span(state.tree, annotation)))
        }
        if (!integer_kind(backing.kind) or backing.nominal != ast.NodeId(maxval!(u32))) {
            return invalid_type(try diagnostics.add(state.diagnostics, .invalid_enum_backing, ast.node_span(state.tree, annotation)))
        }
    }
    count :: ast.enum_member_count(state.tree, id)
    if (count == 0) {
        return invalid_type(try diagnostics.add(state.diagnostics, .invalid_enum_value, ast.node_span(state.tree, id)))
    }
    members :: try mem.alloc(EnumMember, state.enums.allocator, count)
    owned := true
    defer {
        if (owned) mem.free(state.enums.allocator, members)
    }
    next := ConstantInteger{ magnitude = 0 }
    overflow := false
    for 0..count |i| {
        node :: ast.enum_member(state.tree, id, i)
        field :: ast.field(state.tree, node)
        value := next
        valid := !overflow
        if (!explicit) value = ConstantInteger{ magnitude = try global_variant(state, field.name?, Type{ kind = .void }) }
        if (field.value) |expression| {
            if (!explicit) valid = false
            try collect_expression(state, expression)
            if (evaluate_integer(state, expression, true)) |constant| {
                value = constant
                valid = explicit
            } else valid = false
        }
        if (!integer_fits(value, backing.kind)) valid = false
        if (explicit and i != 0 and constant_order(
            ConstantInteger{ magnitude = members[i - 1].magnitude, negative = members[i - 1].negative },
            value,
        ) >= 0) valid = false
        for members[0..i] |member| {
            if (ast.name_id(state.tree, member.name) == ast.name_id(state.tree, field.name?)
                or (member.magnitude == value.magnitude and member.negative == value.negative)) valid = false
        }
        if (!valid) {
            failure :: invalid_type(try diagnostics.add(state.diagnostics, .invalid_enum_value, field.span))
            state.cells[usize(id)].type = failure
            return failure
        }
        members[i] = EnumMember{ name = field.name?, magnitude = value.magnitude, negative = value.negative }
        next = value
        overflow = !value.negative and value.magnitude == maxval!(u64)
        if (value.negative) {
            next.magnitude -= 1
            if (next.magnitude == 0) next.negative = false
        } else if (!overflow) next.magnitude += 1
    }
    try arraylist.append(&state.enums, EnumType{
        declaration = id, backing = backing.kind, explicit_backing = explicit, members = members,
    })
    owned = false
    type :: Type{ kind = .enumeration, enum_type = EnumId(state.enums.items.len - 1) }
    state.cells[usize(id)].type = type
    return type
}

@hide:file
check_union proc(state @mut State, id ast.NodeId, nominal bool) Type ! (mem.AllocError | diagnostics.CapacityError) {
    cached := state.cells[usize(id)].type
    if (cached.kind == .invalid) return cached
    if (!state.cells[usize(id)].record_checking and (cached.kind == .record or cached.kind == .type_value)) {
        cached.kind = .record
        return cached
    }
    if (state.cells[usize(id)].record_checking) {
        if (state.pointer_depth > state.cells[usize(id)].record_pointer_depth) {
            cached.kind = .record
            return cached
        }
        return invalid_type(try diagnostics.add(state.diagnostics, .recursive_record, ast.node_span(state.tree, id)))
    }
    state.cells[usize(id)].record_checking = true
    defer state.cells[usize(id)].record_checking = false
    state.cells[usize(id)].record_pointer_depth = state.pointer_depth
    record_id :: RecordId(state.records.items.len)
    empty :: try mem.alloc(RecordField, state.records.allocator, 0)
    declaration :: if (nominal) id else ast.NodeId(maxval!(u32))
    arraylist.append(&state.records, RecordType{
        declaration = declaration, fields = empty, is_union = true,
    }) catch |err| {
        mem.free(state.records.allocator, empty)
        return err
    }
    result_type :: Type{ kind = .record, record_type = record_id }
    state.cells[usize(id)].type = result_type
    count :: ast.record_field_count(state.tree, id)
    fields :: try mem.alloc(RecordField, state.records.allocator, count)
    owned := true
    defer {
        if (owned) mem.free(state.records.allocator, fields)
    }
    view :: ast.union_type(state.tree, id)
    tag := Type{}
    if (view.tag) |annotation| {
        tag = try check_annotation(state, annotation, false)
        if (tag.kind == .invalid) return tag
        if (tag.kind != .enumeration or tag.nominal != ast.NodeId(maxval!(u32))) {
            return invalid_type(try diagnostics.add(state.diagnostics, .invalid_union_tag, ast.node_span(state.tree, annotation)))
        }
    }
    for 0..count |i| {
        field :: ast.field(state.tree, ast.record_field(state.tree, id, i))
        type :: try check_annotation(state, field.type?, true)
        if (type.kind == .invalid) return type
        if (type.kind == .none or type.kind == .range or type.kind == .type_value or field.value != null
            or (type.kind == .void and tag.kind == .none and !view.auto_tag)) {
            return invalid_type(try diagnostics.add(state.diagnostics, .invalid_record_field_type, field.span))
        }
        if (field.name == null or named_field(state.tree, fields[0..i], field.name?) != no_index) {
            return invalid_type(try diagnostics.add(state.diagnostics, .duplicate_field, field.span))
        }
        fields[i] = RecordField{ name = field.name, type = type, default = null }
    }
    if (tag.kind == .enumeration) {
        descriptor :: state.enums.items[usize(tag.enum_type)]
        for fields |field| {
            if (enum_member_slot(state, descriptor, field.name?) == no_index) {
                return invalid_type(try diagnostics.add(state.diagnostics, .invalid_union_tag, ast.node_span(state.tree, field.name?)))
            }
        }
    }
    declared_tag :: tag
    if (view.auto_tag or tag.kind == .enumeration) {
        members :: try mem.alloc(EnumMember, state.enums.allocator, count)
        members_owned := true
        defer if (members_owned) mem.free(state.enums.allocator, members)
        for fields |field, i| {
            members[i] = EnumMember{
                name = field.name?, magnitude = try global_variant(state, field.name?, field.type),
            }
            if (members[i].magnitude > u64(maxval!(u16))) {
                return invalid_type(try diagnostics.add(state.diagnostics, .invalid_union_tag, ast.node_span(state.tree, id)))
            }
        }
        try arraylist.append(&state.enums, EnumType{ declaration = id, backing = .u16, members = members })
        members_owned = false
        tag = Type{ kind = .enumeration, enum_type = EnumId(state.enums.items.len - 1) }
    }
    mem.free(state.records.allocator, state.records.items[usize(record_id)].fields)
    state.records.items[usize(record_id)].fields = fields
    state.records.items[usize(record_id)].tag_type = tag
    state.records.items[usize(record_id)].declared_tag_type = declared_tag
    owned = false
    state.cells[usize(id)].type = result_type
    return result_type
}

@hide:file
select_enum_member proc(state @mut State, id, name ast.NodeId, type Type) Type ! (mem.AllocError | diagnostics.CapacityError) {
    slot :: enum_member_slot(state, state.enums.items[usize(type.enum_type)], name)
    if (slot == no_index) {
        try fail(state, id, .unknown_field, ast.node_span(state.tree, name))
        seed(state, id, state.types[usize(id)])
        return state.types[usize(id)]
    }
    state.slots[usize(id)] = slot
    state.backings[usize(id)] = type
    state.cells[root(state, usize(id))].expected = type
    seed(state, id, type)
    return type
}

@hide:file
infer_enum_literal proc(state @mut State, id ast.NodeId, expected Type, defaults bool) Type ! (mem.AllocError | diagnostics.CapacityError) {
    if (state.types[usize(id)].kind == .invalid) return state.types[usize(id)]
    name :: ast.enum_literal(state.tree, id)
    if (expected.kind == .enumeration and expected.nominal == ast.NodeId(maxval!(u32))) {
        return try select_enum_member(state, id, name, expected)
    }
    if (expected.kind == .record and expected.nominal == ast.NodeId(maxval!(u32))) {
        descriptor :: state.records.items[usize(expected.record_type)]
        if (descriptor.is_union and descriptor.tag_type.kind == .enumeration) {
            slot :: named_field(state.tree, descriptor.fields, name)
            if (slot == no_index) {
                try fail(state, id, .unknown_field, ast.node_span(state.tree, name))
                return state.types[usize(id)]
            }
            if (descriptor.fields[slot].type.kind != .void) {
                try fail(state, id, .type_mismatch, ast.node_span(state.tree, id))
                return state.types[usize(id)]
            }
            state.variant_slots[usize(id)] = slot
            seed(state, id, expected)
            return expected
        }
    }
    if (defaults or expected.kind != .none) {
        try fail(state, id, .enum_context_required, ast.node_span(state.tree, id))
        seed(state, id, state.types[usize(id)])
        return state.types[usize(id)]
    }
    return Type{}
}

@hide:file
validate_constructor proc(state @mut State, id ast.NodeId) void ! (mem.AllocError | diagnostics.CapacityError) {
    destination :: state.types[usize(id)]
    if (destination.kind == .invalid) return
    if (ast.call_arg_count(state.tree, id) != 1) {
        try fail(state, id, .argument_count_mismatch, ast.node_span(state.tree, id))
        return
    }
    argument :: ast.call_arg(state.tree, id, 0)
    actual :: state.types[usize(argument)]
    if (actual.kind == .invalid) return
    if (actual.nominal != ast.NodeId(maxval!(u32)) and same_type(state, immediate_backing(state, actual), destination)) return
    if (destination.nominal == ast.NodeId(maxval!(u32))) {
        try fail(state, id, .not_callable, ast.node_span(state.tree, ast.call_expr(state.tree, id).callee))
        return
    }
    backing :: state.backings[usize(id)]
    if (backing.nominal == ast.NodeId(maxval!(u32)) and numeric_kind(backing.kind)) {
        source :: immediate_backing(state, actual)
        if (!numeric_kind(source.kind) or source.nominal != ast.NodeId(maxval!(u32))) {
            try fail(state, argument, .invalid_operand, ast.node_span(state.tree, argument))
        }
    } else try compatible(state, argument, backing)
}

@hide:file
infer_variant_payload proc(state @mut State, id ast.NodeId, expected Type, defaults bool) Type ! (mem.AllocError | diagnostics.CapacityError) {
    annotation :: ast.record_literal(state.tree, id).type?
    if (expected.kind == .none and !defaults) return Type{}
    if (expected.kind != .record) {
        try fail(state, id, .enum_context_required, ast.node_span(state.tree, id))
        return state.types[usize(id)]
    }
    descriptor :: state.records.items[usize(expected.record_type)]
    if (!descriptor.is_union or descriptor.tag_type.kind != .enumeration) {
        try fail(state, id, .enum_context_required, ast.node_span(state.tree, id))
        return state.types[usize(id)]
    }
    name :: ast.enum_literal(state.tree, annotation)
    slot :: named_field(state.tree, descriptor.fields, name)
    if (slot == no_index) {
        try fail(state, id, .unknown_field, ast.node_span(state.tree, name))
        return state.types[usize(id)]
    }
    state.variant_slots[usize(id)] = slot
    _ = try select_enum_member(state, annotation, name, descriptor.tag_type)
    payload :: descriptor.fields[slot].type
    count :: ast.record_field_count(state.tree, id)
    direct :: count == 1 and ast.field(state.tree, ast.record_field(state.tree, id, 0)).name == null
    if (direct) {
        value :: ast.field(state.tree, ast.record_field(state.tree, id, 0)).value?
        try demand(state, value, payload, .type_mismatch)
        _ = try infer_shape(state, value, defaults)
        if (state.slots[usize(id)] == no_index) {
            values :: try mem.alloc(ast.NodeId, state.initializers.allocator, descriptor.fields.len)
            errdefer mem.free(state.initializers.allocator, values)
            mem.set(values, ast.NodeId(maxval!(u32)))
            values[slot] = value
            try arraylist.append(&state.initializers, RecordInitializer{ fields = values })
            state.slots[usize(id)] = state.initializers.items.len - 1
        }
    } else {
        if (payload.kind != .record and !(payload.kind == .void and count == 0)) {
            try fail(state, id, .type_mismatch, ast.node_span(state.tree, id))
            return state.types[usize(id)]
        }
        state.backings[usize(id)] = payload
        if (payload.kind == .record) {
            fields :: state.records.items[usize(payload.record_type)].fields
            if (state.slots[usize(id)] == no_index) {
                values :: try mem.alloc(ast.NodeId, state.initializers.allocator, fields.len)
                errdefer mem.free(state.initializers.allocator, values)
                try arraylist.append(&state.initializers, RecordInitializer{ fields = values })
                state.slots[usize(id)] = state.initializers.items.len - 1
            }
            values :: state.initializers.items[state.slots[usize(id)]].fields
            mem.set(values, ast.NodeId(maxval!(u32)))
            for 0..count |i| {
                field :: ast.field(state.tree, ast.record_field(state.tree, id, i))
                index := i
                if (field.name) |field_name| index = named_field(state.tree, fields, field_name)
                if (index >= fields.len) {
                    try fail(state, id, .unknown_field, field.span)
                    continue
                }
                if (values[index] != ast.NodeId(maxval!(u32))) {
                    try fail(state, id, .duplicate_field, field.span)
                    continue
                }
                values[index] = field.value?
                try demand(state, field.value?, fields[index].type, .type_mismatch)
                _ = try infer_shape(state, field.value?, defaults)
            }
            for fields |field, i| {
                if (values[i] != ast.NodeId(maxval!(u32))) continue
                if (field.default) |value| {
                    values[i] = value
                } else try fail(state, id, .missing_field, ast.node_span(state.tree, id))
            }
        }
    }
    if (state.types[usize(id)].kind == .invalid) return state.types[usize(id)]
    seed(state, id, expected)
    return expected
}

@hide:file
collect_match proc(state @mut State, id ast.NodeId) void ! (mem.AllocError | diagnostics.CapacityError) {
    subject :: ast.match_expr(state.tree, id).subject
    try collect_expression(state, subject)
    try depend(state, subject, id)
    for 0..ast.match_arm_count(state.tree, id) |i| {
        arm_id :: ast.match_arm(state.tree, id, i)
        arm :: ast.match_arm_view(state.tree, arm_id)
        for 0..ast.match_pattern_count(state.tree, arm_id) |j| {
            pattern :: ast.match_pattern(state.tree, arm_id, j)
            state.cells[usize(pattern)].match_pattern = true
            try collect_expression(state, pattern)
            try depend(state, pattern, id)
        }
        if (arm.capture) |capture| {
            state.cells[usize(capture)].role = .loop_capture
            state.cells[usize(capture)].fixed = true
            state.cells[usize(capture)].local = true
            binding :: sema.binding(state.resolution, capture)
            if (binding.kind == .invalid) state.cells[usize(capture)].type = invalid_type(binding.data.diagnostic)
            try depend(state, capture, arm.body)
        }
        saved_arm :: state.narrowing_arm
        state.cells[usize(arm_id)].enclosing_arm = saved_arm
        state.cells[usize(arm_id)].match_owner = id
        state.narrowing_arm = arm_id
        if (arm.expression) {
            try collect_expression(state, arm.body)
        } else {
            try collect_block(state, arm.body, state.return_annotation, state.in_loop)
        }
        state.narrowing_arm = saved_arm
    }
}

@hide:file
infer_match proc(state @mut State, id ast.NodeId, defaults bool) Type ! (mem.AllocError | diagnostics.CapacityError) {
    subject :: try infer_shape(state, ast.match_expr(state.tree, id).subject, defaults)
    if (subject.kind == .invalid) {
        seed(state, id, subject)
        return subject
    }
    key := subject
    tagged := false
    if (subject.kind == .record) {
        descriptor :: state.records.items[usize(subject.record_type)]
        tagged = (
            descriptor.is_union and descriptor.tag_type.kind == .enumeration
            and subject.nominal == ast.NodeId(maxval!(u32))
        )
        if (tagged) key = descriptor.tag_type
    }
    if (subject.kind != .none and !numeric_kind(subject.kind) and subject.kind != .bool
        and !(subject.kind == .enumeration and subject.nominal == ast.NodeId(maxval!(u32))) and !tagged) {
        try fail(state, id, .invalid_match_subject, ast.node_span(state.tree, id))
        seed(state, id, state.types[usize(id)])
        return state.types[usize(id)]
    }
    result :: root(state, usize(id))
    expected := state.cells[result].expected
    has_block := false
    has_value := false
    for 0..ast.match_arm_count(state.tree, id) |i| {
        arm_id :: ast.match_arm(state.tree, id, i)
        arm :: ast.match_arm_view(state.tree, arm_id)
        payload := Type{}
        capture_valid := tagged and !arm.catch_all
        for 0..ast.match_pattern_count(state.tree, arm_id) |j| {
            pattern :: ast.match_pattern(state.tree, arm_id, j)
            kind :: ast.expr_kind(state.tree, pattern)
            if (key.kind == .enumeration and kind == .enum_literal) {
                _ = try infer_enum_literal(state, pattern, key, false)
                if (tagged) {
                    fields :: state.records.items[usize(subject.record_type)].fields
                    slot :: named_field(state.tree, fields, ast.enum_literal(state.tree, pattern))
                    if (slot != no_index) {
                        state.variant_slots[usize(pattern)] = slot
                        if (payload.kind == .none) {
                            payload = fields[slot].type
                        } else if (!same_type(state, payload, fields[slot].type)) capture_valid = false
                    } else capture_valid = false
                }
            } else if (key.kind != .none and key.kind != .enumeration) {
                if (kind == .range) {
                    range_view :: ast.range_expr(state.tree, pattern)
                    try demand(state, range_view.start, key, .invalid_match_pattern)
                    try demand(state, range_view.end, key, .invalid_match_pattern)
                } else try demand(state, pattern, key, .invalid_match_pattern)
            }
        }
        if (arm.capture) |capture| {
            if (key.kind != .none and (!capture_valid or payload.kind == .void or payload.kind == .none)) {
                try fail(state, id, .invalid_match_capture, ast.node_span(state.tree, capture))
            } else if (payload.kind != .none and state.cells[usize(capture)].type.kind != .invalid) {
                seed(state, capture, payload)
                for 0..(state.cells.len) |j| {
                    if (state.cells[j].role != .expression or !declaration_reference(state.tree, ast.NodeId(j))) continue
                    binding :: sema.binding(state.resolution, ast.NodeId(j))
                    if (binding.kind == .declaration and binding.data.declaration == capture
                        and !has_narrowing(state, ast.NodeId(j))) seed(state, ast.NodeId(j), payload)
                }
            }
        }
        if (arm.expression) {
            has_value = true
            actual :: try infer_shape(state, arm.body, defaults)
            if (expected.kind == .none and actual.kind != .none and actual.kind != .invalid) expected = actual
        } else has_block = true
    }
    if (has_block and !has_value) expected = Type{ kind = .void }
    if (has_block and has_value and defaults) {
        try fail(state, id, .type_mismatch, ast.node_span(state.tree, id))
    }
    if (expected.kind != .none) {
        for 0..ast.match_arm_count(state.tree, id) |i| {
            arm :: ast.match_arm_view(state.tree, ast.match_arm(state.tree, id, i))
            if (arm.expression) try demand(state, arm.body, expected, .type_mismatch)
        }
        seed(state, id, expected)
    }
    return group_type(state, id)
}

@hide:file
constant_order proc(left, right ConstantInteger) i32 {
    if (left.negative != right.negative) {
        if (left.negative) return -1
        return 1
    }
    if (left.magnitude == right.magnitude) return 0
    less :: left.magnitude < right.magnitude
    if (less != left.negative) return -1
    return 1
}

@hide:file
constant_real proc(state @mut State, id ast.NodeId) ?f64 ! mem.AllocError {
    if (ast.float_value(state.tree, id)) |value| return value
    missing ?f64 :: null
    if (ast.expr_kind(state.tree, id) == .literal_float) {
        return strconv.parse_float(state.edges.allocator, ast.literal_text(state.tree, id)) catch |err| {
            match err {
                .out_of_memory: return err
                .invalid_number, .out_of_range: return missing
            }
        }
    }
    if (evaluate_integer(state, id, true)) |value| {
        real :: f64(value.magnitude)
        if (value.negative) return -real
        return real
    }
    if (ast.expr_kind(state.tree, id) == .unary) {
        view :: ast.unary_expr(state.tree, id)
        if (view.operator == .negate) {
            if (try constant_real(state, view.operand)) |value| return -value
        }
    }
    return missing
}

@hide:file
PatternInterval :: struct {
    low ConstantInteger = ConstantInteger{ magnitude = 0 }
    high ConstantInteger = ConstantInteger{ magnitude = 0 }
    real_low f64 = 0.0
    real_high f64 = 0.0
    real bool = false
    inclusive bool = true
}

@hide:file
pattern_interval proc(state @mut State, id ast.NodeId, key Type) ?PatternInterval ! mem.AllocError {
    missing ?PatternInterval :: null
    low := id
    high := id
    inclusive := true
    if (ast.expr_kind(state.tree, id) == .range) {
        range_view :: ast.range_expr(state.tree, id)
        low = range_view.start
        high = range_view.end
        inclusive = range_view.inclusive
    }
    interval := PatternInterval{ inclusive = inclusive, real = key.kind == .float }
    if (interval.real) {
        if (try constant_real(state, low)) |value| interval.real_low = value else return missing
        if (try constant_real(state, high)) |value| interval.real_high = value else return missing
    } else if (key.kind == .bool) {
        if (ast.expr_kind(state.tree, low) != .literal_bool or low != high) return missing
        value :: mem.eql(ast.literal_text(state.tree, low), "true")
        interval.low.magnitude = if (value) 1 else 0
        interval.high = interval.low
    } else {
        if (evaluate_integer(state, low, true)) |value| interval.low = value else return missing
        if (evaluate_integer(state, high, true)) |value| interval.high = value else return missing
    }
    return interval
}

@hide:file
interval_overlap proc(left, right PatternInterval) bool {
    if (left.real) {
        return (
            (left.real_low < right.real_high or (right.inclusive and left.real_low == right.real_high))
            and (right.real_low < left.real_high or (left.inclusive and right.real_low == left.real_high))
        )
    }
    return (
        (constant_order(left.low, right.high) < 0 or (right.inclusive and constant_order(left.low, right.high) == 0))
        and (constant_order(right.low, left.high) < 0 or (left.inclusive and constant_order(right.low, left.high) == 0))
    )
}

@hide:file
validate_match proc(state @mut State, id ast.NodeId) void ! (mem.AllocError | diagnostics.CapacityError) {
    subject :: state.types[usize(ast.match_expr(state.tree, id).subject)]
    if (subject.kind == .invalid) return
    key := subject
    if (subject.kind == .record) key = state.records.items[usize(subject.record_type)].tag_type
    if (key.kind != .enumeration and !numeric_kind(key.kind) and key.kind != .bool) {
        try fail(state, id, .invalid_match_subject, ast.node_span(state.tree, id))
        return
    }
    covered := usize(0)
    seen_false := false
    seen_true := false
    catch_all := false
    for 0..ast.match_arm_count(state.tree, id) |i| {
        arm_id :: ast.match_arm(state.tree, id, i)
        arm :: ast.match_arm_view(state.tree, arm_id)
        if (catch_all) try fail(state, id, .unreachable_match_arm, ast.node_span(state.tree, arm_id))
        if (arm.catch_all) {
            if (key.kind == .enumeration and covered == state.enums.items[usize(key.enum_type)].members.len) {
                try fail(state, id, .unreachable_match_arm, ast.node_span(state.tree, arm_id))
            }
            if (key.kind == .bool and seen_false and seen_true) {
                try fail(state, id, .unreachable_match_arm, ast.node_span(state.tree, arm_id))
            }
            catch_all = true
        }
        for 0..ast.match_pattern_count(state.tree, arm_id) |j| {
            pattern :: ast.match_pattern(state.tree, arm_id, j)
            actual :: state.types[usize(pattern)]
            if (actual.kind == .invalid) continue
            kind :: ast.expr_kind(state.tree, pattern)
            if (key.kind == .enumeration) {
                if (kind != .enum_literal or !same_type(state, actual, key)) {
                    try fail(state, id, .invalid_match_pattern, ast.node_span(state.tree, pattern))
                    continue
                }
                covered += 1
            } else if (kind == .range) {
                range_view :: ast.range_expr(state.tree, pattern)
                if (key.kind == .bool) try fail(state, id, .invalid_match_pattern, ast.node_span(state.tree, pattern))
                try compatible(state, range_view.start, key)
                try compatible(state, range_view.end, key)
            } else try compatible(state, pattern, key)
            current :: try pattern_interval(state, pattern, key)
            if (current) |interval| {
                if ((interval.real and (interval.real_low > interval.real_high
                        or (!interval.inclusive and interval.real_low == interval.real_high)))
                    or (!interval.real and (constant_order(interval.low, interval.high) > 0
                        or (!interval.inclusive and constant_order(interval.low, interval.high) == 0)))) {
                    try fail(state, id, .invalid_match_pattern, ast.node_span(state.tree, pattern))
                }
                if (key.kind == .bool) {
                    if (interval.low.magnitude == 0) seen_false = true else seen_true = true
                }
            }
            for 0..(i + 1) |previous_i| {
                previous_arm :: ast.match_arm(state.tree, id, previous_i)
                count :: if (previous_i == i) j else ast.match_pattern_count(state.tree, previous_arm)
                for 0..count |previous_j| {
                    previous :: ast.match_pattern(state.tree, previous_arm, previous_j)
                    duplicate := false
                    if (key.kind == .enumeration) {
                        duplicate = (
                            state.slots[usize(previous)] != no_index
                            and state.slots[usize(previous)] == state.slots[usize(pattern)]
                        )
                    } else if (current) |interval| {
                        if (try pattern_interval(state, previous, key)) |other| duplicate = interval_overlap(interval, other)
                    }
                    if (duplicate) try fail(state, id, .duplicate_match_pattern, ast.node_span(state.tree, pattern))
                }
            }
        }
        if (arm.expression) try compatible(state, arm.body, state.types[usize(id)])
    }
    exhaustive :: (
        catch_all
        or (key.kind == .enumeration and covered == state.enums.items[usize(key.enum_type)].members.len)
        or (key.kind == .bool and seen_false and seen_true)
    )
    state.exhaustive[usize(id)] = exhaustive
    if (!exhaustive) try fail(state, id, .non_exhaustive_match, ast.node_span(state.tree, id))
}

@hide:file
global_variant proc(state @mut State, name ast.NodeId, payload Type) u64 ! mem.AllocError {
    for state.variants.items |variant, i| {
        if (ast.name_id(state.tree, variant.name) == ast.name_id(state.tree, name)
            and same_type(state, variant.payload, payload)) return u64(i + 1)
    }
    try arraylist.append(&state.variants, Variant{ name = name, payload = payload })
    return u64(state.variants.items.len)
}

#! applies the same value-type coercion rules used for storage, arguments, and returns.
value_assignable proc(result @Result, actual, expected Type) bool {
    # assignability reads only descriptors, signature annotations, and the borrowed AST.
    state State := undefined
    state.tree = result.storage.tree
    state.types = result.storage.types
    state.arrays = result.storage.arrays
    state.pointers = result.storage.pointers
    state.records = result.storage.records
    state.enums = result.storage.enums
    return assignable_type(&state, actual, expected)
}

#! tests source-error subset membership using the descriptors retained by checking.
error_assignable proc(result @Result, actual, expected Type) bool {
    return error_subset(result.storage.records.items, result.storage.enums.items, actual, expected)
}

@hide:file
error_subset proc(records []RecordType, enums []EnumType, actual, expected Type) bool {
    if (actual.nominal != expected.nominal) return false
    if (actual.kind == .record and expected.kind == .record and actual.record_type == expected.record_type) return true
    if (actual.kind == .enumeration and expected.kind == .enumeration and actual.enum_type == expected.enum_type) return true
    target := expected
    if (expected.kind == .record) {
        descriptor :: records[usize(expected.record_type)]
        if (!descriptor.is_union or descriptor.tag_type.kind != .enumeration) return false
        if (descriptor.composed and actual.kind == .record and !records[usize(actual.record_type)].is_union) {
            for descriptor.fields |field| {
                if (field.type.kind == .record and field.type.record_type == actual.record_type
                    and field.type.nominal == actual.nominal) return true
            }
            return false
        }
        target = descriptor.tag_type
    }
    if (target.kind != .enumeration) return false
    destination :: enums[usize(target.enum_type)]
    source := actual
    if (actual.kind == .record) {
        descriptor :: records[usize(actual.record_type)]
        if (!descriptor.is_union or descriptor.tag_type.kind != .enumeration) return false
        source = descriptor.tag_type
    }
    if (source.kind != .enumeration) return false
    origin :: enums[usize(source.enum_type)]
    if (origin.explicit_backing or destination.explicit_backing) {
        if (!origin.explicit_backing or !destination.explicit_backing
            or origin.declaration != destination.declaration or origin.backing != destination.backing) return false
    }
    for origin.members |member| {
        found := false
        for destination.members |other| {
            if (member.magnitude == other.magnitude and member.negative == other.negative) found = true
        }
        if (!found) return false
    }
    return true
}

@hide:file
type_has_variant proc(state @State, type Type, name ast.NodeId) bool {
    if (type.kind == .enumeration) return enum_member_slot(state, state.enums.items[usize(type.enum_type)], name) != no_index
    if (type.kind != .record) return false
    descriptor :: state.records.items[usize(type.record_type)]
    return (
        descriptor.is_union and descriptor.tag_type.kind == .enumeration
        and named_field(state.tree, descriptor.fields, name) != no_index
    )
}

@hide:file
check_fallible_type proc(state @mut State, id ast.NodeId) Type ! (mem.AllocError | diagnostics.CapacityError) {
    cached := state.cells[usize(id)].type
    if (cached.kind == .type_value) cached.kind = cached.value_kind
    if (cached.kind != .none) return cached
    expression :: ast.binary_expr(state.tree, id)
    success :: try check_annotation(state, expression.left, true)
    failure :: try check_annotation(state, expression.right, false)
    if (success.kind == .invalid) return success
    if (failure.kind == .invalid) return failure
    valid_error :: failure.kind == .enumeration or (failure.kind == .record
        and (!state.records.items[usize(failure.record_type)].is_union
            or state.records.items[usize(failure.record_type)].tag_type.kind == .enumeration))
    if (!valid_error or success.kind == .none or success.kind == .range or success.kind == .type_value
        or success.kind == .anyopaque or has_inferred_count(state, success)) {
        return invalid_type(try diagnostics.add(state.diagnostics, .invalid_fallible_type, ast.node_span(state.tree, id)))
    }
    type :: try intern_array(state, ArrayType{ kind = .fallible, element = success, error_type = failure })
    state.cells[usize(id)].type = type
    return type
}

@hide:file
SumVariant :: struct {
    name ast.NodeId
    payload Type
    tag u64
}

@hide:file
append_sum_variants proc(state @mut State, variants @mut arraylist.ArrayList(SumVariant), type Type) bool ! mem.AllocError {
    if (type.kind == .enumeration) {
        descriptor :: state.enums.items[usize(type.enum_type)]
        if (descriptor.explicit_backing) return false
        for (descriptor.members) |member| try arraylist.append(variants, SumVariant{
            name = member.name, payload = Type{ kind = .void }, tag = member.magnitude,
        })
        return true
    }
    if (type.kind != .record or type.nominal != ast.NodeId(maxval!(u32))) return false
    descriptor :: state.records.items[usize(type.record_type)]
    if (descriptor.is_union) {
        if (descriptor.tag_type.kind != .enumeration) return false
        members :: state.enums.items[usize(descriptor.tag_type.enum_type)].members
        for (descriptor.fields) |field, i| try arraylist.append(variants, SumVariant{
            name = field.name?, payload = field.type, tag = members[i].magnitude,
        })
        return true
    }
    name := ast.NodeId(maxval!(u32))
    for 0..ast.package_decl_count(state.tree) |i| {
        declaration :: ast.package_decl(state.tree, i)
        if (ast.decl_kind(state.tree, declaration) == .statement
            and ast.statement_decl(state.tree, declaration).initializer == descriptor.declaration) name = declaration
    }
    if (name == ast.NodeId(maxval!(u32))) {
        for 0..(state.cells.len) |i| {
            if (state.cells[i].role != .declaration) continue
            if (ast.statement_decl(state.tree, ast.NodeId(i)).initializer == descriptor.declaration) name = ast.NodeId(i)
        }
    }
    if (name == ast.NodeId(maxval!(u32))) return false
    try arraylist.append(variants, SumVariant{ name = name, payload = type, tag = try global_variant(state, name, type) })
    return true
}

@hide:file
check_sum_type proc(state @mut State, id ast.NodeId) Type ! (mem.AllocError | diagnostics.CapacityError) {
    cached := state.cells[usize(id)].type
    if (cached.kind == .type_value) cached.kind = cached.value_kind
    if (cached.kind != .none) return cached
    if (state.cells[usize(id)].record_checking) {
        return invalid_type(try diagnostics.add(state.diagnostics, .recursive_record, ast.node_span(state.tree, id)))
    }
    state.cells[usize(id)].record_checking = true
    defer state.cells[usize(id)].record_checking = false
    expression :: ast.binary_expr(state.tree, id)
    left :: try check_annotation(state, expression.left, false)
    right :: try check_annotation(state, expression.right, false)
    if (left.kind == .invalid) return left
    if (right.kind == .invalid) return right
    variants arraylist.ArrayList(SumVariant) := arraylist.init(state.records.allocator)
    defer arraylist.deinit(&variants)
    valid := try append_sum_variants(state, &variants, left)
    if (valid) valid = try append_sum_variants(state, &variants, right)
    if (!valid) {
        return invalid_type(try diagnostics.add(state.diagnostics, .invalid_sum_type, ast.node_span(state.tree, id)))
    }
    count := usize(0)
    all_void := true
    for 0..(variants.items.len) |i| {
        variant :: variants.items[i]
        duplicate := false
        for variants.items[0..count] |previous| {
            if (ast.name_id(state.tree, previous.name) != ast.name_id(state.tree, variant.name)) continue
            if (previous.tag != variant.tag) {
                return invalid_type(try diagnostics.add(state.diagnostics, .invalid_sum_type, ast.node_span(state.tree, id)))
            }
            duplicate = true
        }
        if (duplicate) continue
        variants.items[count] = variant
        count += 1
        if (variant.payload.kind != .void) all_void = false
    }
    members :: try mem.alloc(EnumMember, state.enums.allocator, count)
    members_owned := true
    defer if (members_owned) mem.free(state.enums.allocator, members)
    for variants.items[0..count] |variant, i| {
        if (variant.tag > u64(maxval!(u16))) {
            return invalid_type(try diagnostics.add(state.diagnostics, .invalid_sum_type, ast.node_span(state.tree, id)))
        }
        members[i] = EnumMember{ name = variant.name, magnitude = variant.tag }
    }
    try arraylist.append(&state.enums, EnumType{ declaration = id, backing = .u16, members = members, composed = true })
    members_owned = false
    tag :: Type{ kind = .enumeration, enum_type = EnumId(state.enums.items.len - 1) }
    type := tag
    if (!all_void) {
        fields :: try mem.alloc(RecordField, state.records.allocator, count)
        errdefer mem.free(state.records.allocator, fields)
        for (variants.items[0..count]) |variant, i| fields[i] = RecordField{
            name = variant.name, type = variant.payload, default = null,
        }
        try arraylist.append(&state.records, RecordType{
            declaration = id, fields = fields, is_union = true, tag_type = tag, composed = true,
        })
        type = Type{ kind = .record, record_type = RecordId(state.records.items.len - 1) }
    }
    state.cells[usize(id)].type = type
    return type
}

@hide:file
seed_capture proc(state @mut State, capture ast.NodeId, type Type) void {
    seed(state, capture, type)
    for 0..(state.cells.len) |i| {
        if (state.cells[i].role != .expression or !declaration_reference(state.tree, ast.NodeId(i))) continue
        binding :: sema.binding(state.resolution, ast.NodeId(i))
        if (binding.kind == .declaration and binding.data.declaration == capture
            and !has_narrowing(state, ast.NodeId(i))) seed(state, ast.NodeId(i), type)
    }
}

@hide:file
infer_fallible_expression proc(state @mut State, id ast.NodeId, defaults bool) Type ! (mem.AllocError | diagnostics.CapacityError) {
    catching :: ast.expr_kind(state.tree, id) == .catch_expr
    operand :: if (catching) ast.catch_expr(state.tree, id).operand else ast.type_operand(state.tree, id)
    source :: try infer_shape(state, operand, defaults)
    if (source.kind == .invalid) {
        seed(state, id, source)
        return source
    }
    if (source.kind != .fallible) {
        if (defaults and source.kind != .none) {
            try fail(state, id, .invalid_fallible_operand, ast.node_span(state.tree, operand))
            seed(state, id, state.types[usize(id)])
        }
        return group_type(state, id)
    }
    descriptor :: state.arrays.items[usize(source.array_type)]
    seed(state, id, descriptor.element)
    if (catching) {
        expression :: ast.catch_expr(state.tree, id)
        if (expression.capture) |capture| seed_capture(state, capture, descriptor.error_type)
        if (!expression.handler_is_block) {
            try demand(state, expression.handler, descriptor.element, .catch_type_mismatch)
            _ = try infer_shape(state, expression.handler, defaults)
        }
    }
    return group_type(state, id)
}

@hide:file
validate_fallible_expression proc(state @mut State, id ast.NodeId) void ! (mem.AllocError | diagnostics.CapacityError) {
    catching :: ast.expr_kind(state.tree, id) == .catch_expr
    operand :: if (catching) ast.catch_expr(state.tree, id).operand else ast.type_operand(state.tree, id)
    source :: state.types[usize(operand)]
    if (source.kind == .invalid) return
    if (source.kind != .fallible) {
        try fail(state, id, .invalid_fallible_operand, ast.node_span(state.tree, operand))
        return
    }
    descriptor :: state.arrays.items[usize(source.array_type)]
    if (catching) {
        expression :: ast.catch_expr(state.tree, id)
        if (expression.handler_is_block) {
            if (descriptor.element.kind != .void and block_falls_through(state, expression.handler)) {
                try fail(state, expression.handler, .catch_type_mismatch, ast.node_span(state.tree, expression.handler))
            }
        } else {
            actual :: state.types[usize(expression.handler)]
            if (actual.kind != .invalid and !assignable_value(state, expression.handler, actual, descriptor.element)) {
                try fail(state, expression.handler, .catch_type_mismatch, ast.node_span(state.tree, expression.handler))
            }
        }
        return
    }
    if (state.cells[usize(id)].in_cleanup) {
        try fail(state, id, .cleanup_control_flow, ast.node_span(state.tree, id))
        return
    }
    annotation :: state.cells[usize(id)].return_annotation
    if (annotation == ast.NodeId(maxval!(u32))) {
        try fail(state, id, .try_outside_fallible, ast.node_span(state.tree, id))
        return
    }
    result :: state.types[usize(annotation)]
    if (result.kind == .invalid) return
    if (result.kind != .fallible) {
        try fail(state, id, .try_outside_fallible, ast.node_span(state.tree, id))
    } else if (!error_subset(state.records.items, state.enums.items, descriptor.error_type,
        state.arrays.items[usize(result.array_type)].error_type)) {
        try fail(state, id, .incompatible_propagated_error, ast.node_span(state.tree, id))
    }
}

@hide:file
matching_narrowing_arm proc(state @State, id ast.NodeId) ast.NodeId {
    binding :: sema.binding(state.resolution, id)
    if (binding.kind != .declaration) return ast.NodeId(maxval!(u32))
    target :: binding.data.declaration
    if (state.cells[usize(target)].role == .declaration
        and ast.statement_decl(state.tree, target).mutability == .variable) return ast.NodeId(maxval!(u32))
    arm := state.cells[usize(id)].narrowing_arm
    while (arm != ast.NodeId(maxval!(u32))) {
        owner :: state.cells[usize(arm)].match_owner
        subject :: ast.match_expr(state.tree, owner).subject
        original :: sema.binding(state.resolution, subject)
        if (original.kind == .declaration and original.data.declaration == binding.data.declaration) return arm
        arm = state.cells[usize(arm)].enclosing_arm
    }
    return ast.NodeId(maxval!(u32))
}

@hide:file
has_narrowing proc(state @State, id ast.NodeId) bool {
    return matching_narrowing_arm(state, id) != ast.NodeId(maxval!(u32))
}

@hide:file
arm_names_variant proc(state @State, arm, name ast.NodeId) bool {
    for 0..ast.match_pattern_count(state.tree, arm) |i| {
        pattern :: ast.match_pattern(state.tree, arm, i)
        if (ast.expr_kind(state.tree, pattern) == .enum_literal
            and ast.name_id(state.tree, ast.enum_literal(state.tree, pattern)) == ast.name_id(state.tree, name)) return true
    }
    return false
}

@hide:file
arm_keeps_variant proc(state @State, owner, arm, name ast.NodeId) bool {
    if (!ast.match_arm_view(state.tree, arm).catch_all) return arm_names_variant(state, arm, name)
    for 0..ast.match_arm_count(state.tree, owner) |i| {
        previous :: ast.match_arm(state.tree, owner, i)
        if (previous == arm) break
        if (ast.match_arm_view(state.tree, previous).catch_all or arm_names_variant(state, previous, name)) return false
    }
    return true
}

@hide:file
narrow_reference proc(state @mut State, id ast.NodeId) Type ! (mem.AllocError | diagnostics.CapacityError) {
    arm :: matching_narrowing_arm(state, id)
    if (arm == ast.NodeId(maxval!(u32))) return Type{}
    cached :: state.cells[usize(arm)].narrowed_type
    if (cached.kind != .none) return cached
    owner :: state.cells[usize(arm)].match_owner
    subject :: ast.match_expr(state.tree, owner).subject
    source :: try infer_shape(state, subject, false)
    key := source
    if (source.kind == .record) {
        descriptor :: state.records.items[usize(source.record_type)]
        if (!descriptor.is_union) return source
        key = descriptor.tag_type
    }
    if (key.kind != .enumeration) return source
    descriptor :: state.enums.items[usize(key.enum_type)]
    count := usize(0)
    for descriptor.members |member| {
        if (arm_keeps_variant(state, owner, arm, member.name)) count += 1
    }
    if (count == descriptor.members.len) {
        state.cells[usize(arm)].narrowed_type = source
        return source
    }
    members :: try mem.alloc(EnumMember, state.enums.allocator, count)
    members_owned := true
    defer if (members_owned) mem.free(state.enums.allocator, members)
    next := usize(0)
    for descriptor.members |member| {
        if (!arm_keeps_variant(state, owner, arm, member.name)) continue
        members[next] = member
        next += 1
    }
    try arraylist.append(&state.enums, EnumType{
        declaration = descriptor.declaration, backing = descriptor.backing,
        explicit_backing = descriptor.explicit_backing, members = members, composed = true,
    })
    members_owned = false
    tag :: Type{ kind = .enumeration, enum_type = EnumId(state.enums.items.len - 1) }
    narrowed := tag
    if (source.kind == .record) {
        original :: state.records.items[usize(source.record_type)]
        fields :: try mem.alloc(RecordField, state.records.allocator, count)
        errdefer mem.free(state.records.allocator, fields)
        next = 0
        for original.fields |field| {
            if (!arm_keeps_variant(state, owner, arm, field.name?)) continue
            fields[next] = field
            next += 1
        }
        try arraylist.append(&state.records, RecordType{
            declaration = ast.NodeId(maxval!(u32)), fields = fields, is_union = true,
            tag_type = tag, composed = true,
        })
        narrowed = Type{ kind = .record, record_type = RecordId(state.records.items.len - 1) }
    }
    state.cells[usize(arm)].narrowed_type = narrowed
    return narrowed
}