try lowerModuleTreeInto(ctx, &mut *low, graph, childId, false, pkg);

    }

}

/// Build a scope access chain: a::b::c from a slice of identifiers.

    let mut result = ast::synthNode(

        arena,

        ast::NodeValue::Ident(strings::intern(&mut STRING_POOL, path[0]))

    );

    for i in 1..path.len {

        emit::emit(&mut generator.e, word);

    }

}

/// Finish RV64 code generation and return the emitted program.

    generator: &mut Generator,

    globalData: *[il::Data],

    storage: Storage,

    roDataPrefix: *[u8],

    roDataBuf: *mut [u8],

unsafe fn write(out: &mut sexpr::Output, s: &[u8]) {

    sexpr::write(out, s);

}

/// Format `i32` into arena.

    let mut digits: [u8; 12] = undefined;

    let start = fmt::formatI32(val, &mut digits[..]);

    let slice = try! alloc::allocSlice(a, 1, 1, digits.len - start) as *mut [u8];

    try! mem::copy(slice, &digits[start..]);

    return slice;

}

/// Format `u32` into arena.

    let mut digits: [u8; 10] = undefined;

    let start = fmt::formatU32(val, &mut digits[..]);

    let slice = try! alloc::allocSlice(a, 1, 1, digits.len - start) as *mut [u8];

    try! mem::copy(slice, &digits[start..]);

        nextId: 0,

    };

}

/// Create an empty `*mut [*Node]` slice with the given capacity.

    if capacity == 0 {

        return &mut [];

    }

    let ptr = try! alloc::allocSlice(&mut arena.arena, @sizeOf(*Node), @alignOf(*Node), capacity);

        else => return false,

    }

}

/// Allocate a new AST node from the arena with the given span and value.

    let p = try! alloc::alloc(&mut arena.arena, @sizeOf(Node), @alignOf(Node));

    let node = p as *mut Node;

    let nodeId = arena.nextId;

    set arena.nextId = nodeId + 1;

    return node;

}

/// Allocate a synthetic AST node with a zero-length span.

    return allocNode(arena, Span { offset: 0, length: 0 }, value);

}

/// Synthetic module with a single function in it.

record SynthFnMod: Copy {

        case types::PointerClass::Unsafe => return unsafeHead,

    }

}

/// Convert a type signature to an S-expression.

    match sig {

        case super::TypeSig::Void => return sexpr::sym("void"),

        case super::TypeSig::Opaque => return sexpr::sym("opaque"),

        case super::TypeSig::Bool => return sexpr::sym("bool"),

        case super::TypeSig::Integer { width, sign } => return sexpr::sym(intTypeName(width, sign)),

        }

    }

}

/// Convert a node slice to a slice of expressions.

    if nodes.len == 0 {

        return &[];

    }

    let buf = try! sexpr::allocExprs(a, nodes.len as u32);

    for node, i in nodes {

    }

    return buf;

}

/// Convert optional attributes to an attribute list expression.

    let mut exprs: *[sexpr::Expr] = &[];

    if let list = attrs {

        set exprs = nodeListToExprs(a, &list.list[..]);

    }

    return sexpr::list(a, "attrs", exprs);

}

/// Convert an optional node to an expression, or return placeholder.

    if let n = opt {

        return toExpr(a, n);

    }

    return sexpr::sym("_");

}

/// Convert an optional node to an expression, or return `Null`.

    if let n = opt {

        return toExpr(a, n);

    }

    return sexpr::Expr::Null;

}

/// Convert an optional guard.

    if let g = guard {

        return sexpr::list(a, "guard", &[toExpr(a, g)]);

    }

    return sexpr::Expr::Null;

}

/// Convert a list of match prongs to expressions.

    if nodes.len == 0 {

        return &[];

    }

    let buf = try! sexpr::allocExprs(a, nodes.len as u32);

    for prong, i in nodes {

    }

    return buf;

}

/// Convert a match prong to an S-expression.

    match p.arm {

        case super::ProngArm::Case(patterns) => {

            return sexpr::block(a, "case", &[

                sexpr::list(a, "patterns", nodeListToExprs(a, &patterns[..])),

                guardExpr(a, p.guard)

        }

    }

}

/// Convert a record field declaration to an S-expression.

    a: &mut alloc::Arena,

    field: ?*super::Node,

    type: *super::Node,

    value: ?*super::Node

) -> sexpr::Expr {

    return sexpr::list(a, ":", &[toExprOpt(a, field), toExpr(a, type), toExprOrNull(a, value)]);

}

/// Convert a list of record fields to expressions.

    if nodes.len == 0 {

        return &[];

    }

    let buf = try! sexpr::allocExprs(a, nodes.len as u32);

    for node, i in nodes {

    }

    return buf;

}

/// Convert a union variant to an S-expression.

    return sexpr::list(a, "variant", &[toExpr(a, name), toExprOrNull(a, type)]);

}

/// Convert a list of union variants to expressions.

    if nodes.len == 0 {

        return &[];

    }

    let buf = try! sexpr::allocExprs(a, nodes.len as u32);

    for node, i in nodes {

    }

    return buf;

}

/// Convert an AST node to an S-expression.

    match node.value {

        case super::NodeValue::Placeholder => return sexpr::sym("_"),

        case super::NodeValue::Nil => return sexpr::sym("nil"),

        case super::NodeValue::Undef => return sexpr::sym("undefined"),

        case super::NodeValue::Bool(v) => {

}

/// Emit data bytes for a single section (read-only or read-write) into `buf`.

/// Iterates data requiring sidecar image bytes, serializing each data item.

/// Returns the total number of bytes written.

    items: *[il::Data],

    dataSymMap: &DataSymMap,

    fnLabels: &labels::Labels,

    codeBase: u32,

    buf: *mut [u8],

) -> u32 {

    return emitSectionAtOffset(items, dataSymMap, fnLabels, codeBase, buf, readOnly, 0);

}

/// Emit data bytes for a single section starting at `startOffset`.

    items: *[il::Data],

    dataSymMap: &DataSymMap,

    fnLabels: &labels::Labels,

    codeBase: u32,

    buf: *mut [u8],

        usedCalleeSaved,

    };

}

/// Create an empty register map.

    let virtRegs = try alloc::allocSlice(arena, @sizeOf(u32), @alignOf(u32), MAX_ACTIVE) as *mut [u32];

    let physRegs = try alloc::allocSlice(arena, @sizeOf(gen::Reg), @alignOf(gen::Reg), MAX_ACTIVE) as *mut [gen::Reg];

    return RegMap { virtRegs, physRegs, n: 0 };

}

    }

    panic "rallocReg: no free register, spilling fault";

}

/// Record the current index; forward traversal leaves the last operand use.

    recordLastUse(reg, ctxPtr as &mut LastUseCtx);

}

/// Record the last instruction that uses the register.

fn recordLastUse(reg: il::Reg, ctx: &mut LastUseCtx) {

        bitset::put(c.uses, reg.n);

    }

}

/// Callback for [`il::forEachReg`]: updates max register number.

    updateMaxReg(reg, ctx as &mut u32);

}

/// Update the largest register number.

fn updateMaxReg(reg: il::Reg, max: &mut u32) {

    il::forEachReg(instr, findRegCallback, &mut ctx as &mut opaque);

    return ctx.found;

}

/// Callback for [`il::forEachReg`]: sets found if register matches target.

    findReg(reg, ctx as &mut FindCtx);

}

/// Set the match flag when the register equals the target.

fn findReg(reg: il::Reg, c: &mut FindCtx) {

        }

    }

}

/// Callback for [`il::forEachReg`]: increments use count for register.

    countRegUse(reg, ctxPtr as &mut CountCtx);

}

/// Add the block weight to the register use count.

fn countRegUse(reg: il::Reg, ctx: &mut CountCtx) {

/// Separator for qualified symbol names.

export constant PATH_SEPARATOR: *[u8] = "::";

/// Format a qualified symbol name: `pkg::mod::path::name`.

    let mut totalLen: u32 = name.len;

    for segment in path {

        set totalLen += segment.len + PATH_SEPARATOR.len;

    }

    let buf = try! alloc::allocSlice(arena, 1, 1, totalLen) as *mut [u8];

use std::io;

use std::lang::sexpr;

use std::lang::alloc;

/// Format a u32 and allocate the result in the arena.

    let mut digits: [u8; 10] = undefined;

    let start = fmt::formatU32(id, &mut digits[..]);

    let ptr = try alloc::allocSlice(a, 1, 1, digits.len - start) catch { return "?"; };

    let slice = ptr as *mut [u8];

    try mem::copy(slice, &digits[start..]) catch { return "?"; };

        case super::ModuleState::Ready => return sexpr::sym("ready"),

    }

}

/// Recursively convert a module entry and its descendants to an S-expression.

    a: &mut alloc::Arena,

    graph: &super::ModuleGraph,

    entry: *super::ModuleEntry

) -> sexpr::Expr {

    let idText = formatId(a, entry.id as u32);

    ty: Type,

    next: ?*TypeNode,

}

/// Allocate and intern a type in the arena, returning a pointer for deduplication.

    // Search existing types for a match.

    let mut cursor = self.types;

    while let node = cursor {

        if node.ty == ty {

            return &node.ty;

    return &node.ty;

}

/// Allocate a nominal type descriptor and return a pointer to it.

    // Nb. We don't attempt to de-duplicate nominal type entries,

    // since they don't carry node information and we create

    // placeholder entries when binding symbols.

    let entry = try! alloc::alloc(

        &mut self.arena, @sizeOf(NominalType), @alignOf(NominalType)

    return entry;

}

/// Allocate a function type descriptor and return a pointer to it.

    let entry = try! alloc::alloc(

        &mut self.arena, @sizeOf(FnType), @alignOf(FnType)

    ) as *mut FnType;

    set *entry = info;

    /// Root AST node.

    rootAst: *ast::Node,

}

/// Construct a resolver with module context and backing storage.

    storage: ResolverStorage,

    config: Config

) -> Resolver {

    let mut arena = storage.arena;

    let symbols = try! alloc::allocSlice(

fn emitTypeMismatch(self: &mut Resolver, node: ?*ast::Node, mismatch: TypeMismatch) -> ResolveError {

    return emitError(self, node, ErrorKind::TypeMismatch(mismatch));

}

/// Allocate a scope object with the given symbol capacity.

    // Check for an existing scope for this node, and don't allocate a new

    // one in that case.

    if let scope = scopeFor(self, owner) {

        return scope;

    }

}

/// Enter a new local scope that is the child of the current scope.

/// This creates a parent/child relationship that means that lookups in the

/// child scope can recurse upwards.

    let scope = allocScope(self, owner, MAX_LOCAL_SYMBOLS);

    set scope.parent = self.scope;

    set self.scope = scope;

    return scope;

}

/// Enter a module scope. Returns an object that can be used to exit the scope.

    let prevScope = self.scope;

    let prevMod = self.currentMod;

    let scope = allocScope(self, owner, MAX_MODULE_SYMBOLS);

    set self.scope = scope;

    }

    return arg;

}

/// Allocate a new symbol, and return a reference to it.

    let sym = try! alloc::alloc(&mut self.arena, @sizeOf(Symbol), @alignOf(Symbol)) as *mut Symbol;

    set *sym = Symbol { name, data, attrs, node, moduleId: nil };

    return sym;

}

    }

    return actualTy;

}

/// Bind an identifier in the given scope.

    self: &mut Resolver,

    name: *[u8],

    owner: *ast::Node,

    data: SymbolData,

    attrs: u32,

    }

    return sym;

}

/// Bind a constant identifier in the current scope.

    self: &mut Resolver,

    ident: *ast::Node,

    owner: *ast::Node,

    type: Type,

    val: ?ConstValue,

}

/// Bind a module identifier in the given scope.

/// This is used when declaring modules with `mod` or

/// importing modules with `use`.

    self: &mut Resolver,

    entry: *module::ModuleEntry,

    scope: *mut Scope,

    owner: *ast::Node,

    attrs: u32,

    return try bindIdent(self, name, owner, data, attrs, bindingScope);

}

/// Bind a type identifier in the current scope.

    self: &mut Resolver,

    ident: *ast::Node,

    owner: *ast::Node,

    type: *mut NominalType,

    attrs: u32

    set *nominalTy = NominalType::Record(recordType);

}

/// Bind a type name.

    throws (ResolveError)

{

    let attrMask = resolveAttributes(self, attrs);

    try ensureDefaultAttrNotAllowed(self, node, attrMask);

    return try bindTypeIdent(self, name, node, nominalTy, attrMask);

}

/// Allocate a trait type descriptor and return a pointer to it.

    let p = try! alloc::alloc(&mut self.arena, @sizeOf(TraitType), @alignOf(TraitType));

    let entry = p as *mut TraitType;

    set *entry = TraitType { name, methods: &mut [], supertraits: &mut [] };

    return entry;

}

/// Bind a trait name in the current scope.

    throws (ResolveError)

{

    let attrMask = resolveAttributes(self, attrs);

    try ensureDefaultAttrNotAllowed(self, node, attrMask);

                set valid = true;

            }

        }

    }

    if valid {

        // Propagate the constant value after applying the cast's target-width

        // truncation and signed interpretation.

        if let value = constValueEntry(self, expr.value) {

            if let case ConstValue::Int(i) = value {

                setNodeConstValue(self, node, castConstInt(i, targetTy));

    }

}

/// Bind all type names in a module.

/// Skips declarations that have already been bound.

    for node in block.statements {

        match node.value {

            case ast::NodeValue::RecordDecl(decl) => {

                if symbolFor(self, node) == nil {

                    try bindTypeName(self, node, decl.name, decl.attrs) catch {};

// Opaque pointer tests.

/// You can assign any pointer (*T) to an opaque pointer (*opaque) without a cast.

@test unsafe fn testOpaquePointerAutoCoercion() throws (testing::TestError) {

    let mut a = testResolver();

    try expectNoErrors(&result);

}

/// You cannot assign an opaque pointer to a non-opaque pointer without a cast.

@test unsafe fn testOpaquePointerNoReverseCoercion() throws (testing::TestError) {

}

/// Test that you can dereference after casting.

@test unsafe fn testOpaquePointerDereferenceAfterCast() throws (testing::TestError) {

    let mut a = testResolver();

    try expectNoErrors(&result);

}

/// You cannot do pointer arithmetic with an opaque pointer.

@test unsafe fn testOpaquePointerNoArithmetic() throws (testing::TestError) {

        let mut a = testResolver();

        let result = try resolveBlockStr(&mut a, "let f: fn() = undefined; f as u32;");

        try expectNoErrors(&result);

    } { // *u8 to *i32 (u8 to i32 is valid).

        let mut a = testResolver();

        try expectNoErrors(&result);

    } { // **u8 to **i32 (*u8 to *i32 is valid).

        let mut a = testResolver();

        try expectNoErrors(&result);

    }

    { // *[i32] to *[opaque].

        let mut a = testResolver();

        let result = try resolveBlockStr(&mut a, "let s: *[i32] = undefined; s as *[opaque];");

        try expectNoErrors(&result);

    } { // *[opaque] to *[i32].

        let mut a = testResolver();

        try expectNoErrors(&result);

    }

    { // *[i32] to *[u8].

        let mut a = testResolver();

        try expectNoErrors(&result);

    } { // *[record] to *[u8].

        let mut a = testResolver();

        try expectNoErrors(&result);

    }

    { // *[u8] to *[i32].

        let mut a = testResolver();

        try expectNoErrors(&result);

    } { // *[*u8] to *[*i32]

        let mut a = testResolver();

        try expectNoErrors(&result);

    }

    { // Identity cast: *mut [i32] to *mut [i32].

        let mut a = testResolver();

    try expectAnalyzeOk("unsafe fn run(p: *u8) -> *u8 { return 1 + p; }");

    try expectAnalyzeOk("unsafe fn run(p: *mut u8) -> *mut u8 { return p - 1; }");

    try expectAnalyzeOk("fn run(value: u32) -> u32 { return value + 1; }");

}

/// Unsafe declarations may compose unsafe operations and calls.

@test unsafe fn testUnsafePointerOperationsAllowed() throws (testing::TestError) {

    let program = "record Marker: Once {} unsafe fn load(pointer: *unsafe u32) -> u32 { return *pointer; } unsafe fn run(pointer: *unsafe u32) -> u32 { let next = pointer + 1; let same = pointer == next; return load(pointer); }";

    try expectAnalyzeOk(program);

}

    /// A block with a name, inline items, and child statements on separate lines.

    Block { name: *[u8], items: *[Expr], children: *[Expr] },

}

/// Allocate an array of Expr in the arena.

    if len == 0 {

        throw alloc::AllocError::OutOfMemory;

    }

    let ptr = try alloc::allocSlice(arena, @sizeOf(Expr), @alignOf(Expr), len);

    return ptr as *mut [Expr];

}

/// Allocate and copy items into the arena.

    if items.len == 0 {

        return &[];

    }

    let buf = try! allocExprs(a, items.len);

    for item, i in items {

export fn str(s: *[u8]) -> Expr {

    return Expr::Str(s);

}

/// Shorthand for creating a list.

    return Expr::List { head, tail: allocItems(a, tail), multiline: false };

}

/// Shorthand for creating a bracket-delimited vector.

    return Expr::Vec { items: allocItems(a, items) };

}

/// Shorthand for creating a block with inline items and child expressions.

    return Expr::Block { name, items: allocItems(a, items), children: allocItems(a, children) };

}

/// Write a string to the output target.

export unsafe fn write(out: &mut Output, s: &[u8]) {

/// Pop an element from the end of the vector.

///

/// Copies the element into the provided output pointer.

/// Returns false if the vector is empty.

    if vec.len == 0 {

        return false;

    }

    set vec.len -= 1;

}

/// Set the element at the given index.

///

/// Returns false if index is out of bounds.

    if index >= vec.len {

        return false;

    }

    let off: u32 = index * vec.stride;

    copyBytes(&mut vec.data[off..off + vec.stride], @sliceOf(elem as &u8, vec.stride));

fn i32ToI16(x: i32) -> i16 {

    return x as i16;

}

/// Cast pointer types (same size, no instruction).

    return x as *i32;

}

/// Update the maximum register count through a borrowed counter.

fn updateMax(reg: Reg, max: &mut u32) {

    set *max = maxRegNum(reg.n, *max);

}