/// Synthesize a `testing::test("mod", "name", mod::fn)` call for one test.

fn synthTestCall(arena: *mut ast::NodeArena, desc: *TestDesc) -> *ast::Node {

    let callee = synthScopeAccess(arena, &["testing", "test"]);

    let modStr = il::formatQualifiedName(

        &mut arena.arena,

        desc.modPath[desc.modPath.len - 1]

    );

    let modArg = ast::synthNode(arena, ast::NodeValue::String(modStr));

    let nameArg = ast::synthNode(arena, ast::NodeValue::String(desc.fnName));

    for i in 0..entries.len {

        let entry = &entries[i];

        let modEntry = module::get(graph, entry.moduleId) else {

            panic "writeDebugInfo: module not found for debug entry";

        };

        buf[pos] = 0;

        pos = pos + 1;

    }

}

/// Run the resolver on the parsed modules.

fn runResolver(ctx: *mut CompileContext, nodeCount: u32) -> resolver::Resolver throws (Error) {

    let mut mainArena = alloc::new(&mut MAIN_ARENA[..]);

                for _ in 0..v.count {

                    match v.item {

                        case il::DataItem::Val { typ, val } => {

                            let size = il::typeSize(typ);

                            let valPtr = &val as *u8;

                            offset = offset + size;

                        },

                        case il::DataItem::Sym(name) => {

                            let addr = lookupDataSymAddr(dataSyms, name) else {

                                panic "emitSection: data symbol not found";

                            let lo: u32 = addr;

                            let hi: u32 = 0;

                            let loPtr = &lo as *u8;

                            let hiPtr = &hi as *u8;

                            offset = offset + 8;

                        },

                        case il::DataItem::Fn(name) => {

                            let addr = codeBase + labels::funcOffset(fnLabels, name) as u32;

                            let lo: u32 = addr;

                            let hi: u32 = 0;

                            let loPtr = &lo as *u8;

                            let hiPtr = &hi as *u8;

                            offset = offset + 8;

                        },

                        case il::DataItem::Str(s) => {

                            offset = offset + s.len;

                        },

                        case il::DataItem::Undef => {

                            buf[offset] = 0;

                            offset = offset + 1;

        emit::emit(&mut e, encode::nop()); // Placeholder for two-instruction jump.

        emit::emit(&mut e, encode::nop()); //

    }

    // Generate code for all functions.

    for i in 0..program.fns.len {

        let func = program.fns[i];

        if not func.isExtern {

            let checkpoint = alloc::save(arena);

// Code Access  //

//////////////////

/// Get emitted code as a slice.

pub fn getCode(e: *Emitter) -> *[u32] {

}

/// Get function addresses for printing.

pub fn getFuncs(e: *Emitter) -> *[FuncAddr] {

}

/// Record a debug entry mapping the current PC to a source location.

/// Deduplicates consecutive entries with the same location.

pub fn recordSrcLoc(e: *mut Emitter, loc: il::SrcLoc) {

    e.debugEntriesLen = e.debugEntriesLen + 1;

}

/// Get debug entries as a slice.

pub fn getDebugEntries(e: *Emitter) -> *[DebugEntry] {

}

pub fn printCode(pkgName: *[u8], code: *[u32], funcs: *[emit::FuncAddr], arena: *mut alloc::Arena, buf: *mut [u8]) -> *[u8] {

    let mut pos: u32 = 0;

    let mut out = sexpr::Output::Buffer { buf, pos: &mut pos };

    printCodeTo(&mut out, pkgName, code, funcs, arena);

}

    let mut out: *[*[u8]] = &[];

    match node.kind {

        case Kind::Name(name) if name.len > 0 => {

            buf[0] = name;

        }

        case Kind::Pair { a, b } => {

        }

        else => {}

    }

    return out;

}

}

@default fn main() -> i32 {

    let all: *[i32] = &DATA[..];

    let head: i32 = sumPair(all);

    return head + tail + mid;

}

        return 2;

    }

    // Count number tokens using for-in.

    let mut numCount: u32 = 0;

    for tok in slice {

        match tok {

            case Token::Number(_) => {

                numCount = numCount + 1;

            }

//! returns: 42

fn testBasicSubslice() -> bool {

    let arr: [i32; 5] = [10, 20, 30, 40, 50];

    let slice: *[i32] = &arr[..];        // Full slice [10, 20, 30, 40, 50]

    return subslice[0] == 20 and subslice[1] == 30 and subslice[2] == 40;

}

fn testNestedSubslice() -> bool {

    let arr: [i32; 6] = [100, 200, 300, 400, 500, 600];

    let slice1: *[i32] = &arr[1..5];     // [200, 300, 400, 500]

    return slice3[0] == 300;

}

fn testSubsliceLength() -> bool {

    let arr: [i32; 4] = [1, 2, 3, 4];

    let slice: *[i32] = &arr[..];

    return subslice.len == 2;

}

fn testEdgeCases() -> bool {

    let arr: [i32; 3] = [7, 8, 9];

    let slice: *[i32] = &arr[..];

    // Test single element subslice

    if (single[0] != 8 or single.len != 1) {

        return false;

    }

    // Test empty subslice

    if (empty.len != 0) {

        return false;

    }

    return true;

}

            x = x / 10;

        }

    }

    // Return the slice from the start of the written number to

    // the end of the buffer.

}

/// Format a i32 by writing it to the provided buffer.

pub fn formatI32(val: i32, buffer: *mut [u8]) -> *[u8] {

    debug::assert(buffer.len >= I32_STR_LEN);

        if neg {

            i = i - 1;

            buffer[i] = '-';

        }

    }

}

/// Format a u64 by writing it to the provided buffer.

pub fn formatU64(val: u64, buffer: *mut [u8]) -> *[u8] {

    debug::assert(buffer.len >= U64_STR_LEN);

            i = i - 1;

            buffer[i] = ('0' + (x % 10) as u8);

            x = x / 10;

        }

    }

}

/// Format a i64 by writing it to the provided buffer.

pub fn formatI64(val: i64, buffer: *mut [u8]) -> *[u8] {

    debug::assert(buffer.len >= I64_STR_LEN);

        if neg {

            i = i - 1;

            buffer[i] = '-';

        }

    }

}

/// Format a i8 by writing it to the provided buffer.

pub fn formatI8(val: i8, buffer: *mut [u8]) -> *[u8] {

    return formatI32(val as i32, buffer);

/// Format a bool by writing it to the provided buffer.

pub fn formatBool(val: bool, buffer: *mut [u8]) -> *[u8] {

    if val {

        try! mem::copy(buffer, "true");

    } else {

        try! mem::copy(buffer, "false");

    }

}

pub fn readToEnd(buf: *mut [u8]) -> *[u8] {

    let mut total: u32 = 0;

    while total < buf.len {

        let n: u32 = read(chunk);

        if n == 0 {

            break;

        }

            total = buf.len;

            break;

        }

        total = total + n;

    }

}

    return arena.data.len as u32 - arena.offset;

}

/// Returns the remaining buffer as a mutable slice.

pub fn remainingBuf(arena: *mut Arena) -> *mut [u8] {

}

/// Commits `size` bytes of allocation, advancing the offset.

/// Use after writing to the buffer returned by [`remainingBuf`].

pub fn commit(arena: *mut Arena, size: u32) {

    }

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

    let mut pos: u32 = 0;

    for segment in path {

    }

}

///////////

// Types //

///////////

fn prefixStr(a: *mut alloc::Arena, prefix: u8, str: *[u8]) -> *[u8] {

    let len = str.len + 1;

    let ptr = try! alloc::allocSlice(a, 1, 1, len);

    let slice = ptr as *mut [u8];

    slice[0] = prefix;

    return slice;

}

/// Format a register reference (`%n`).

        write(out, ")");

    }

    write(out, "\n");

    // Instructions.

    for i in 0..instrs.len {

        indent(out, 1);

        writeInstr(out, a, blocks, instrs[i]);

        write(out, ";\n");

    }

) -> *[u8] {

    let mut pos: u32 = 0;

    let mut out = sexpr::Output::Buffer { buf, pos: &mut pos };

    printProgram(&mut out, arena, program);

}

}

/// Return the accumulated values.

fn dataBuilderFinish(b: *DataValueBuilder) -> ConstDataResult {

    return ConstDataResult {

        isUndefined: b.allUndef,

    };

}

///////////////////////////

        options: LowerOptions { debug: false, buildTest: false },

    };

    let defaultFnIdx = try lowerDecls(&mut low, root, true);

    return il::Program {

        defaultFnIdx,

    };

}

/////////////////////////////////

}

/// Finalize lowering and return the unified IL program.

pub fn finalize(low: *Lowerer, defaultFnIdx: ?u32) -> il::Program {

    return il::Program {

        defaultFnIdx,

    };

}

/////////////////////////////////

    let mut digits: [u8; fmt::U32_STR_LEN] = undefined;

    let suffixText = fmt::formatU32(suffix, &mut digits[..]);

    let totalLen = base.len + suffixText.len;

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

}

/// Generate a unique label by appending the global counter to the base.

fn nextLabel(self: *mut FnLowerer, base: *[u8]) -> *[u8] throws (LowerError) {

    let idx = self.labelCounter;

    let suffix = fmt::formatU32(count, &mut digits[..]);

    let suffixStart = prefix.len + 1;

    let totalLen = suffixStart + suffix.len;

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

    buf[prefix.len] = '$';

}

/// Append a data entry using a declaration-scoped name (`prefix$N`).

fn pushDeclData(

    self: *mut Lowerer,

    values[0] = il::DataValue {

        item: il::DataItem::Str(s),

        count: 1

    };

}

/// Compare two data items for structural equality.

/// Unlike raw byte comparison, this correctly ignores padding bytes in unions.

fn dataItemEq(a: il::DataItem, b: il::DataItem) -> bool {

    let mut count: u32 = 0;

    for i in 0..self.blockCount {

        let data = &self.blockData[i];

        blocks[count] = il::Block {

            label: data.label,

            params,

            instrs: data.instrs,

            preds,

            loopDepth: data.loopDepth,

        };

        count = count + 1;

    }

}

/////////////////////

// Loop Management //

/////////////////////

    }

    emit(self, il::Instr::Switch {

        val: subject.val,

        defaultTarget: blocks[defaultIdx].n,

        defaultArgs: &mut [],

    });

    for i in 0..prongs.len {

        let p = prongs.list[i];

        let case ast::NodeValue::MatchProng(prong) = p.value

/// Lower a subscript expression.

fn lowerSubscript(self: *mut FnLowerer, node: *ast::Node, container: *ast::Node, index: *ast::Node) -> il::Val

    throws (LowerError)

{

    }

    let result = try lowerElemPtr(self, container, index);

    return emitRead(self, result.elemReg, 0, result.elemType);

}

    }

    emit(self, il::Instr::Switch {

        val: il::Val::Reg(tagReg),

        defaultTarget: defaultTarget.n,

        defaultArgs: &mut [],

    });

    // Second pass: emit each catch clause body.

    for i in 0..catches.len {

        let clauseNode = catches.list[i];

/// Returns a subslice with explicit bounds.

fn sliceRange(s: *[i32], start: u32, end: u32) -> *[i32] {

}

/// Returns a subslice with an open end bound.

fn sliceRangeOpenEnd(s: *[i32], start: u32) -> *[i32] {

}

/// Returns a subslice with an open start bound.

fn sliceRangeOpenStart(s: *[i32], end: u32) -> *[i32] {

}

/// Returns a full reslice of a slice.

fn sliceRangeFull(s: *[i32]) -> *[i32] {

}

/// Returns a subslice from an array parameter.

fn sliceArray(a: [i32; 4]) -> *[i32] {

    return &a[1..3];

    return m.children[index];

}

/// Public accessor for a module's directory prefix.

pub fn moduleDir(m: *ModuleEntry) -> *[u8] {

}

/// Public accessor to the logical module path segments.

pub fn moduleQualifiedPath(m: *ModuleEntry) -> *[*[u8]] {

    debug::assertMsg(m.pathDepth > 0, "moduleQualifiedPath: path must not be empty");

    // Split on '/' to extract all but the last component.

    for i in 0..filePath.len {

        if filePath[i] == PATH_SEP {

            if i > last {

                debug::assertMsg(count < components.len, "parsePath: output slice is large enough");

                count = count + 1;

            }

            last = i + 1;

        }

    }

        return nil; // Path ends with separator or is empty.

    }

    // Handle the last component by removing extension.

    debug::assertMsg(count < components.len, "parsePath: output slice is large enough");

        components[count] = name;

    } else {

        return nil;

    };

    count = count + 1;

    }

    let childName = childPath[childPath.len - 1];

    // Navigate through all but the last segment to find the parent.

    let mut parentId = root;

        let child = findChild(graph, part, parentId) else {

            throw ModuleError::MissingParent;

        };

        parentId = child.id;

    }

fn basenameSlice(path: *[u8]) -> *[u8] throws (ModuleError) {

    let start = basenameStart(path);

    let withoutExt = trimExtension(path) else {

        throw ModuleError::InvalidPath;

    };

}

/// Find the byte offset immediately following the last separator.

fn basenameStart(path: *[u8]) -> u32 {

    let mut start: u32 = 0;

    for i in 0..SOURCE_EXT.len {

        if path[extStart + i] != SOURCE_EXT[i] {

            return nil;

        }

    }

}

/// Strip prefix from path, and return the suffix.

fn stripPathPrefix(prefix: *[*[u8]], path: *[*[u8]]) -> ?*[*[u8]] {

    if prefix.len == 0 {

    for segment, i in prefix {

        if not mem::eq(segment, path[i]) {

            return nil;

        }

    }

}

            return nodeChar(p, ch);

        }

        case scanner::TokenKind::String => {

            advance(p);

            let src = p.previous.source;

            // Process escape sequences into arena buffer.

            let buf = alloc::remainingBuf(&mut p.arena.arena);

            let len = unescapeString(raw, buf);

            alloc::commit(&mut p.arena.arena, len);

        }

        case scanner::TokenKind::Underscore => {

            advance(p);

            return node(p, ast::NodeValue::Placeholder);

        }

fn tryParseAnnotation(p: *mut Parser) -> ?*ast::Node {

    if not check(p, scanner::TokenKind::AtIdent) {

        return nil;

    }

    // Token is @identifier, skip the '@' to get the name.

    if ident == "@default" {

        advance(p); // Consume `@default`.

        return nodeAttribute(p, ast::Attribute::Default);

    }

    if ident == "@test" {

        case ast::NodeValue::Ident(name) if name.len > 0 => {

            if buf.len < 1 {

                panic "flattenPath: invalid output buffer size";

            }

            buf[0] = name;

        }

        case ast::NodeValue::ScopeAccess(access) => {

            // Recursively flatten parent path.

            let parent = try flattenPath(self, access.parent, buf);

            if parent.len >= buf.len {

                panic "flattenPath: invalid output buffer size";

            }

            let child = try nodeName(self, access.child);

            buf[parent.len] = child;

        }

        case ast::NodeValue::Super => {

            // `super` is handled by scope adjustment in `checkSuperAccess`.

            // Return empty prefix so the path continues from the next segment.

            return out;

        }

        else => {

            // Fallthrough to error.

        }

    }

    // Start by finding the root of the path.

    let root = path[0];

    let sym = findInScopeRecursive(scope, root, isAnySymbol) else

        throw emitError(self, node, ErrorKind::UnresolvedSymbol(root));

    // Check visibility for symbol.

    if not isSymbolVisible(sym, scope, self.scope) {

        throw emitError(self, node, ErrorKind::UnresolvedSymbol(root));

    }

    }

    let parentName = path[0];

    // First, check if this is a sub-module of the start scope.

    if let sym = findSymbolInScope(startScope, parentName) {

    }

    // Not a sub-module, so look in the global scope for a package root.

    let sym = findSymbolInScope(self.pkgScope, parentName)

        else throw emitError(self, module, ErrorKind::UnresolvedSymbol(parentName));

}

/// Recursively resolve the remaining path segments by traversing child modules.

fn resolveModulePathRecursive(

    self: *mut Resolver,

        throw emitError(self, node, ErrorKind::UnresolvedSymbol(childName));

    }

    return try resolveModulePathRecursive(

        self,

        node,

        childSym

    );

}

/// Resolve a type name, which could be an identifier or scoped path.

/// Analyze an array or slice subscript expression.

fn resolveSubscript(self: *mut Resolver, node: *ast::Node, container: *ast::Node, indexNode: *ast::Node) -> Type

    throws (ResolveError)

{

    }

    let subjectTy = autoDeref(containerTy);

    match subjectTy {

        case Type::Array(arrayInfo) => {

            return try setNodeType(self, node, *arrayInfo.item);

        }

            return try setNodeType(self, node, *item);

        }

        else => {

            throw emitError(self, container, ErrorKind::ExpectedIndexable);

        }

    if let case ast::NodeValue::Subscript { container, index } = addr.target.value {

        if let case ast::NodeValue::Range(range) = index.value {

            let containerTy = try infer(self, container);

            let subjectTy = autoDeref(containerTy);

            }

        }

    }

    // Derive a hint for the target type from the slice hint.

    let mut targetHint: Type = Type::Unknown;

    if let case Type::Slice { item, .. } = hint {

    let program = "let xs: [u8; 2] = [1, 2]; xs[..];";

    let result = try resolveProgramStr(&mut a, program);

    try expectErrorKind(&result, super::ErrorKind::SliceRequiresAddress);

}

@test fn testResolveSliceRangeOutOfBounds() throws (testing::TestError) {

    {

        let mut a = testResolver();

        let program = "let xs: [u8; 2] = [1, 2]; let slice = &xs[..3];";

        let result = try resolveProgramStr(&mut a, program);

    return false;

}

/// Create a token from the current scanner state.

fn tok(s: *Scanner, kind: TokenKind) -> Token {

}

/// Create an invalid token with the given message.

pub fn invalid(offset: u32, message: *[u8]) -> Token {

    return Token { kind: TokenKind::Invalid, source: message, offset };

/// Scan an identifier, keyword, or label.

fn scanIdentifier(s: *mut Scanner) -> Token {

    while let ch = current(s); isAlpha(ch) or isDigit(ch) or ch == '_' or ch == '#' {

        advance(s);

    }

    let kind = keywordOrIdent(ident);

    // Only intern actual identifiers, not keywords.

    if kind == TokenKind::Ident {

        return Token { kind, source: strings::intern(s.pool, ident), offset: s.token };

            }

            // Must have at least one character after `@`.

            if s.cursor - s.token <= 1 {

                return invalid(s.token, "expected identifier after `@`");

            }

            return Token {

                kind: TokenKind::AtIdent,

                source: strings::intern(s.pool, name),

                offset: s.token,

            };

    let mut c: u16 = 1;

    if offset >= source.len {

        return nil;

    }

        if ch == '\n' {

            c = 1;

            l = l + 1;

        } else {

            c = c + 1;

    for i in 0..prefix.len {

        if prefix[i] != input[i] {

            return nil;

        }

    }

}

/// Align value up to alignment boundary.

pub fn alignUp(value: u32, alignment: u32) -> u32 {

    return (value + alignment - 1) & ~(alignment - 1);

/// Reads from a file descriptor until EOF or buffer is full.

/// Returns the total number of bytes read, or a negative value on error.

pub fn readToEnd(fd: i32, buf: *mut [u8]) -> i32 {

    let mut total: u32 = 0;

    while total < buf.len {

        let n = read(fd, chunk);

        if n < 0 {

            return n;

        }

        return nil;

    }

    if n < 0 {

        return nil;

    }

}

/// Exit the current process with the given status code.

pub fn exit(status: i32) {

    intrinsics::ecall(93, status, 0, 0, 0);

    if fd < 0 {

        return false;

    }

    let mut written: u32 = 0;

    while written < data.len {

        let n = write(fd, chunk);

        if n <= 0 {

            close(fd);

            return false;

        }

        if line[i] != ' ' and line[i] != '\t' {

            end = i + 1;

        }

        i = i + 1;

    }

}

/// Get next line from string at offset. Returns the line and updates offset past newline.

fn nextLine(s: *[u8], offset: *mut u32) -> *[u8] {

    let start = *offset;

    let mut i = start;

    while i < s.len and s[i] != '\n' {

        i = i + 1;

    }

    if i < s.len {

        *offset = i + 1;

    } else {

        *offset = i;

    }

    if len < 4 {

        return nil;

    }

    // Check for .rad extension.

    let extStart = len - 4; // TODO: language support for additions in ranges.

        return nil;

    }

    if len + 1 > buf.len {

        return nil;

    }

    buf[len - 3] = 'r';

    buf[len - 2] = 'i';

    buf[len - 1] = 'l';

    buf[len] = 0;

}

/// Run a single lowering test case. Returns `true` on success.

fn runTest(sourcePath: *[u8]) -> bool {

    // Buffers for file I/O.