//! Radiance compiler front-end.

use std::mem;

use std::fmt;

use std::io;

use std::lang::alloc;

use std::lang::ast;

use std::lang::parser;

use std::lang::scanner;

use std::lang::resolver;

use std::lang::module;

use std::lang::strings;

use std::lang::package;

use std::lang::il;

use std::lang::lower;

use std::arch::rv64;

use std::arch::rv64::printer;

use std::lang::sexpr;

use std::lang::gen::data;

use std::lang::gen::types;

use std::sys;

use std::sys::unix;

use std::collections::dict;

/// Maximum number of modules we can load per package.

const MAX_LOADED_MODULES: u32 = 64;

/// Maximum number of packages we can compile.

const MAX_PACKAGES: u32 = 4;

/// Total module entries across all packages.

const MAX_TOTAL_MODULES: u32 = 192;

/// Source code buffer arena (2 MB).

const MAX_SOURCES_SIZE: u32 = 2097152;

/// Maximum number of test functions we can discover.

const MAX_TESTS: u32 = 1024;

/// Temporary arena size (32 MB) - retains all parsed AST until resolution.

/// Used for: AST during parsing, then codegen scratch space.

const TEMP_ARENA_SIZE: u32 = 33554432;

/// Main arena size (128 MB) - lives throughout compilation.

/// Used for: resolver data, types, symbols, lowered IL.

const MAIN_ARENA_SIZE: u32 = 134217728;

/// Temporary storage arena - reusable between phases.

static TEMP_ARENA: [u8; TEMP_ARENA_SIZE] = undefined;

/// Main storage arena - persists throughout compilation.

static MAIN_ARENA: [u8; MAIN_ARENA_SIZE] = undefined;

/// Module source code.

static MODULE_SOURCES: [u8; MAX_SOURCES_SIZE] = undefined;

/// Module entries for all packages.

static MODULE_ENTRIES: [module::ModuleEntry; MAX_TOTAL_MODULES] = undefined;

/// String pool.

static STRING_POOL: strings::Pool = strings::Pool { table: undefined, count: 0 };

/// Package scope.

static RESOLVER_PKG_SCOPE: resolver::Scope = undefined;

/// Errors emitted by resolver.

static RESOLVER_ERRORS: [resolver::Error; resolver::MAX_ERRORS] = undefined;

/// Code generation storage.

static CODEGEN_DATA_SYMS: [data::DataSym; data::MAX_DATA_SYMS] = undefined;

/// Hash table entries for data symbol lookup.

static CODEGEN_DATA_SYM_ENTRIES: [dict::Entry; data::DATA_SYM_TABLE_SIZE] = undefined;

/// Debug info file extension.

const DEBUG_EXT: *[u8] = ".debug";

/// Read-only data file extension.

const RO_DATA_EXT: *[u8] = ".ro.data";

/// Read-write data file extension.

const RW_DATA_EXT: *[u8] = ".rw.data";

/// Maximum rodata size (1MB).

const MAX_RO_DATA_SIZE: u32 = 1048576;

/// Maximum rwdata size (1MB).

const MAX_RW_DATA_SIZE: u32 = 1048576;

/// Maximum path length.

const MAX_PATH_LEN: u32 = 256;

/// Read-only data buffer.

static RO_DATA_BUF: [u8; MAX_RO_DATA_SIZE] = undefined;

/// Read-write data buffer.

static RW_DATA_BUF: [u8; MAX_RW_DATA_SIZE] = undefined;

/// Usage string.

const USAGE: *[u8] =

    "usage: radiance -pkg <name> -mod <input>.. [-pkg <name> -mod <input>..] -entry <pkg> -o <output>\n";

/// Compiler error.

union Error {

    Other,

}

/// What to dump during compilation.

union Dump {

    /// Don't dump anything.

    None,

    /// Dump the parsed AST before semantic analysis.

    Ast,

    /// Dump the module graph.

    Graph,

    /// Dump the IL.

    Il,

    /// Dump the generated assembly.

    Asm,

}

/// A discovered test function.

record TestDesc {

    /// Full module qualified path segments (eg. ["std", "tests"]).

    modPath: *[*[u8]],

    /// Test function name (eg. "testFoo").

    fnName: *[u8],

}

/// Compilation context.

record CompileContext {

    /// Array of packages to compile.

    packages: [package::Package; MAX_PACKAGES],

    /// Number of packages.

    packageCount: u32,

    /// Index of entry package.

    entryPkgIdx: ?u32,

    /// Global module graph shared by all packages.

    graph: module::ModuleGraph,

    /// Resolver configuration.

    config: resolver::Config,

    /// What to dump during compilation.

    dump: Dump,

    /// Output path for binary.

    outputPath: ?*[u8],

    /// Whether to emit debug info (.debug file).

    debug: bool,

}

/// Root module info for a package.

record RootModule {

    entry: *module::ModuleEntry,

    ast: *mut ast::Node,

}

/// Print a log line for the given package.

fn pkgLog(pkg: *package::Package, msg: *[*[u8]]) {

    io::printError("radiance: ");

    io::printError(pkg.name);

    io::printError(": ");

    for part, i in msg {

        io::printError(part);

        if i < msg.len - 1 {

            io::printError(" ");

        }

    }

    io::printError("\n");

}

/// Register, load, and parse `path` within `pkg`.

fn processModule(

    pkg: *mut package::Package,

    graph: *mut module::ModuleGraph,

    path: *[u8],

    nodeArena: *mut ast::NodeArena,

    sourceArena: *mut alloc::Arena

) throws (Error) {

    pkgLog(pkg, &["parsing", "(", path, ")", ".."]);

    let moduleId = try package::registerModule(pkg, graph, path) catch {

        io::printError("radiance: error registering module\n");

        throw Error::Other;

    };

    // Read file into remaining arena space.

    let buffer = alloc::remainingBuf(sourceArena);

    if buffer.len == 0 {

        io::printError("radiance: fatal: source arena exhausted\n");

        throw Error::Other;

    }

    let source = unix::readFile(path, buffer) else {

        io::printError("radiance: error reading file\n");

        throw Error::Other;

    };

    if source.len == buffer.len {

        io::printError("radiance: fatal: source arena too small, file truncated: ");

        io::printError(path);

        io::printError("\n");

        throw Error::Other;

    }

    // Commit only what was read.

    alloc::commit(sourceArena, source.len);

    let ast = try parser::parse(scanner::SourceLoc::File(path), source, nodeArena, &mut STRING_POOL) catch {

        throw Error::Other;

    };

    try module::setAst(graph, moduleId, ast) catch {

        io::printError("radiance: error setting AST\n");

        throw Error::Other;

    };

    try module::setSource(graph, moduleId, source) catch {

        io::printError("radiance: error setting source\n");

        throw Error::Other;

    };

}

/// Consume the next argument, or print an error and throw.

fn nextArg(args: *[*[u8]], idx: *mut u32, msg: *[u8]) -> *[u8] throws (Error) {

    *idx += 1;

    if *idx >= args.len {

        io::printError(msg);

        throw Error::Other;

    }

    return args[*idx];

}

/// Parse CLI arguments and return compilation context.

fn processCommand(

    args: *[*[u8]],

    arena: *mut ast::NodeArena

) -> CompileContext throws (Error) {

    let mut buildTest = false;

    let mut debugEnabled = false;

    let mut outputPath: ?*[u8] = nil;

    let mut dump = Dump::None;

    let mut entryPkgName: ?*[u8] = nil;

    // Per-package module path tracking.

    let mut moduleCounts: [u32; MAX_PACKAGES] = undefined;

    let mut modulePaths: [[*[u8]; MAX_LOADED_MODULES]; MAX_PACKAGES] = undefined;

    let mut pkgNames: [*[u8]; MAX_PACKAGES] = undefined;

    let mut pkgCount: u32 = 0;

    let mut currentPkgIdx: ?u32 = nil;

    for i in 0..MAX_PACKAGES {

        moduleCounts[i] = 0;

    }

    if args.len == 0 {

        io::printError(USAGE);

        throw Error::Other;

    }

    let mut idx: u32 = 0;

    while idx < args.len {

        let arg = args[idx];

        if mem::eq(arg, "-pkg") {

            try nextArg(args, &mut idx, "radiance: `-pkg` requires a package name\n");

            if pkgCount >= MAX_PACKAGES {

                io::printError("radiance: too many packages specified\n");

                throw Error::Other;

            }

            pkgNames[pkgCount] = args[idx];

            currentPkgIdx = pkgCount;

            pkgCount += 1;

        } else if mem::eq(arg, "-mod") {

            try nextArg(args, &mut idx, "radiance: `-mod` requires a module path\n");

            let pkgIdx = currentPkgIdx else {

                io::printError("radiance: `-mod` must follow a `-pkg` argument\n");

                throw Error::Other;

            };

            if moduleCounts[pkgIdx] >= MAX_LOADED_MODULES {

                io::printError("radiance: too many modules specified for package\n");

                throw Error::Other;

            }

            modulePaths[pkgIdx][moduleCounts[pkgIdx]] = args[idx];

            moduleCounts[pkgIdx] += 1;

        } else if mem::eq(arg, "-entry") {

            try nextArg(args, &mut idx, "radiance: `-entry` requires a package name\n");

            entryPkgName = args[idx];

        } else if mem::eq(arg, "-test") {

            buildTest = true;

        } else if mem::eq(arg, "-debug") {

            debugEnabled = true;

        } else if mem::eq(arg, "-o") {

            try nextArg(args, &mut idx, "radiance: `-o` requires an output path\n");

            outputPath = args[idx];

        } else if mem::eq(arg, "-dump") {

            try nextArg(args, &mut idx, "radiance: `-dump` requires a mode (eg. ast)\n");

            let mode = args[idx];

            if mem::eq(mode, "ast") {

                dump = Dump::Ast;

            } else if mem::eq(mode, "graph") {

                dump = Dump::Graph;

            } else if mem::eq(mode, "il") {

                dump = Dump::Il;

            } else if mem::eq(mode, "asm") {

                dump = Dump::Asm;

            } else {

                io::printError("radiance: unknown dump mode `");

                io::printError(mode);

                io::printError("` (expected: ast, graph, il, asm)\n");

                throw Error::Other;

            }

        } else {

            io::printError("radiance: unknown argument `");

            io::printError(arg);

            io::printError("`\n");

            throw Error::Other;

        }

        idx += 1;

    }

    if pkgCount == 0 {

        io::printError("radiance: no package specified\n");

        throw Error::Other;

    }

    // Determine entry package index.

    let mut entryPkgIdx: ?u32 = nil;

    if pkgCount == 1 {

        // Single package: it is the entry.

        entryPkgIdx = 0;

    } else {

        // Multiple packages: need -entry.

        let entryName = entryPkgName else {

            io::printError("radiance: `-entry` required when multiple packages specified\n");

            throw Error::Other;

        };

        for i in 0..pkgCount {

            if mem::eq(pkgNames[i], entryName) {

                entryPkgIdx = i;

                break;

            }

        }

        if entryPkgIdx == nil {

            io::printError("radiance: fatal: entry package `");

            io::printError(entryName);

            io::printError("` not found\n");

            throw Error::Other;

        }

    }

    let graph = module::moduleGraph(&mut MODULE_ENTRIES[..], &mut STRING_POOL, arena);

    let mut ctx = CompileContext {

        packages: undefined,

        packageCount: pkgCount,

        entryPkgIdx,

        graph,

        config: resolver::Config { buildTest },

        dump,

        outputPath,

        debug: debugEnabled,

    };

    // Initialize and parse all packages.

    let mut sourceArena = alloc::new(&mut MODULE_SOURCES[..]);

    for i in 0..pkgCount {

        package::init(&mut ctx.packages[i], i as u16, pkgNames[i], &mut STRING_POOL);

        for j in 0..moduleCounts[i] {

            let path = modulePaths[i][j];

            try processModule(&mut ctx.packages[i], &mut ctx.graph, path, arena, &mut sourceArena);

        }

    }

    return ctx;

}

/// Get the entry package from the context.

fn getEntryPackage(ctx: *CompileContext) -> *package::Package throws (Error) {

    let entryIdx = ctx.entryPkgIdx else {

        io::printError("radiance: no entry package specified\n");

        throw Error::Other;

    };

    return &ctx.packages[entryIdx];

}

/// Get root module info from a package.

fn getRootModule(pkg: *package::Package, graph: *module::ModuleGraph) -> RootModule throws (Error) {

    let rootId = pkg.rootModuleId else {

        io::printError("radiance: no root module found\n");

        throw Error::Other;

    };

    let rootEntry = module::get(graph, rootId) else {

        io::printError("radiance: root module entry not found\n");

        throw Error::Other;

    };

    let rootAst = rootEntry.ast else {

        io::printError("radiance: root module has no AST\n");

        throw Error::Other;

    };

    return RootModule { entry: rootEntry, ast: rootAst };

}

/// Dump the module graph.

fn dumpGraph(ctx: *CompileContext) {

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

    module::printer::printGraph(&ctx.graph, &mut arena);

}

/// Dump the parsed AST.

fn dumpAst(ctx: *CompileContext) throws (Error) {

    let pkg = try getEntryPackage(ctx);

    let root = try getRootModule(pkg, &ctx.graph);

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

    ast::printer::printTree(root.ast, &mut arena);

}

/// Lower all packages into a single IL program.

/// Dependencies are lowered first, then the entry package.

fn lowerAllPackages(

    ctx: *mut CompileContext,

    res: *mut resolver::Resolver

) -> il::Program throws (Error) {

    let entryIdx = ctx.entryPkgIdx else {

        panic "lowerAllPackages: no entry package";

    };

    let entryPkg = &ctx.packages[entryIdx];

    // Create the lowerer accumulator using entry package's name.

    let options = lower::LowerOptions { debug: ctx.debug, buildTest: ctx.config.buildTest };

    let mut low = lower::lowerer(res, &ctx.graph, entryPkg.name, &mut res.arena, options);

    // Lower all packages except entry.

    for i in 0..ctx.packageCount {

        if i != entryIdx {

            try lowerPackage(ctx, res, &mut low, &mut ctx.packages[i], false);

        }

    }

    // Lower entry package.

    let defaultFn = try lowerPackage(ctx, res, &mut low, &mut ctx.packages[entryIdx], true);

    // Finalize and return the unified program.

    return lower::finalize(&low, defaultFn);

}

/// Lower all modules in a package into the lowerer accumulator.

fn lowerPackage(

    ctx: *CompileContext,

    res: *mut resolver::Resolver,

    low: *mut lower::Lowerer,

    pkg: *mut package::Package,

    isEntry: bool

) -> ?u32 throws (Error) {

    let rootId = pkg.rootModuleId else {

        io::printError("radiance: no root module found\n");

        throw Error::Other;

    };

    // Set lowerer's package context for qualified name generation.

    // TODO: We shouldn't have to call this manually.

    lower::setPackage(low, &ctx.graph, pkg.name);

    return try lowerModuleTreeInto(ctx, low, &ctx.graph, rootId, isEntry, pkg);

}

/// Recursively lower a module and all its children into the accumulator.

fn lowerModuleTreeInto(

    ctx: *CompileContext,

    low: *mut lower::Lowerer,

    graph: *module::ModuleGraph,

    modId: u16,

    isRoot: bool,

    pkg: *package::Package

) -> ?u32 throws (Error) {

    let entry = module::get(graph, modId) else {

        io::printError("radiance: module entry not found\n");

        throw Error::Other;

    };

    let modAst = entry.ast else {

        io::printError("radiance: module has no AST\n");

        throw Error::Other;

    };

    pkgLog(pkg, &["lowering", "(", entry.filePath, ")", ".."]);

    let defaultFn = try lower::lowerModule(low, modId, modAst, isRoot) catch err {

        io::printError("radiance: internal error during lowering: ");

        lower::printError(err);

        io::printError("\n");

        throw Error::Other;

    };

    // Recurse into children.

    for i in 0..entry.childrenLen {

        let childId = module::childAt(entry, i);

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

    }

    return defaultFn;

}

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

fn synthScopeAccess(arena: *mut ast::NodeArena, path: *[*[u8]]) -> *ast::Node {

    let mut result = ast::synthNode(

        arena,

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

    );

    for i in 1..path.len {

        let child = ast::synthNode(

            arena,

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

        );

        result = ast::synthNode(arena, ast::NodeValue::ScopeAccess(ast::Access {

            parent: result, child,

        }));

    }

    return result;

}

/// Check if a function declaration has the `@test` attribute and return its name if so.

fn getTestFnName(decl: *ast::FnDecl) -> ?*[u8] {

    let attrs = decl.attrs else { return nil; };

    if not ast::attributesContains(&attrs, ast::Attribute::Test) {

        return nil;

    }

    let case ast::NodeValue::Ident(name) = decl.name.value

        else return nil;

    return name;

}

/// Scan a single module's AST for `@test` functions and append them to `tests`.

fn collectModuleTests(

    entry: *module::ModuleEntry,

    tests: *mut [TestDesc],

    testCount: *mut u32

) {

    let modAst = entry.ast else {

        return;

    };

    let case ast::NodeValue::Block(block) = modAst.value else {

        return;

    };

    let modPath = module::moduleQualifiedPath(entry);

    for stmt in block.statements {

        if let case ast::NodeValue::FnDecl(decl) = stmt.value {

            if let fnName = getTestFnName(&decl) {

                if *testCount < tests.len {

                    tests[*testCount] = TestDesc { modPath, fnName };

                    *testCount += 1;

                } else {

                    panic "collectModuleTests: too many tests";

                }

            }

        }

    }

}

/// 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],

        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));

    // Intra-package path: skip the package name prefix.

    let mut funcPath: [*[u8]; 16] = undefined;

    for j in 1..desc.modPath.len {

        funcPath[j - 1] = desc.modPath[j];

    }

    funcPath[desc.modPath.len - 1] = desc.fnName;

    let funcArg = synthScopeAccess(arena, &funcPath[..desc.modPath.len]);

    let a = alloc::arenaAllocator(&mut arena.arena);

    let args = ast::nodeSlice(arena, 3)

        .append(modArg, a)

        .append(nameArg, a)

        .append(funcArg, a);

    return ast::synthNode(arena, ast::NodeValue::Call(ast::Call { callee, args }));

}

/// Inject a test runner into the entry package's root module.

///

/// Scans all parsed modules for `@test fn` declarations, then appends

/// a synthetic entry point to the root module's AST block:

///

/// ```

/// @default fn #testMain() -> i32 {

///     return testing::runAllTests(&[

///         testing::test("std::tests", "testFoo", tests::testFoo),

///         ...

///     ]);

/// }

/// ```

///

/// Uses `#`-prefixed names to avoid conflicts with user code.

fn generateTestRunner(

    ctx: *mut CompileContext,

    arena: *mut ast::NodeArena

) throws (Error) {

    let entryPkg = try getEntryPackage(ctx);

    let root = try getRootModule(entryPkg, &ctx.graph);

    // Collect all test functions across all modules.

    let mut tests: [TestDesc; MAX_TESTS] = undefined;

    let mut testCount: u32 = 0;

    for modIdx in 0..ctx.graph.entriesLen {

        if let entry = module::get(&ctx.graph, modIdx as u16) {

            collectModuleTests(entry, &mut tests[..], &mut testCount);

        }

    }

    if testCount == 0 {

        io::printError("radiance: fatal: no test functions found\n");

        throw Error::Other;

    }

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

    let countStr = fmt::formatU32(testCount, &mut countBuf[..]);

    pkgLog(entryPkg, &["found", countStr, "test(s)"]);

    // Synthesize the `@default` function and append to the root module.

    let fnDecl = synthTestMainFn(arena, &tests[..testCount]);

    injectIntoBlock(root.ast, arena, fnDecl);

}

/// Synthesize the test entry point.

fn synthTestMainFn(arena: *mut ast::NodeArena, tests: *[TestDesc]) -> *ast::Node {

    // Build array literal: `[testing::test(...), ...]`.

    let a = alloc::arenaAllocator(&mut arena.arena);

    let mut elements = ast::nodeSlice(arena, tests.len as u32);

    for i in 0..tests.len {

        elements.append(synthTestCall(arena, &tests[i]), a);

    }

    let arrayLit = ast::synthNode(arena, ast::NodeValue::ArrayLit(elements));

    // Build: `&[...]`.

    let testsRef = ast::synthNode(arena, ast::NodeValue::AddressOf(ast::AddressOf {

        target: arrayLit, mutable: false,

    }));

    // Build: `testing::runAllTests(&[...])`.

    let runFn = synthScopeAccess(arena, &["testing", "runAllTests"]);

    let callArgs = ast::nodeSlice(arena, 1).append(testsRef, a);

    let callExpr = ast::synthNode(arena, ast::NodeValue::Call(ast::Call {

        callee: runFn, args: callArgs,

    }));

    // Build: `return testing::runAllTests(&[...]);`

    let retStmt = ast::synthNode(arena, ast::NodeValue::Return { value: callExpr });

    let bodyStmts = ast::nodeSlice(arena, 1).append(retStmt, a);

    let fnBody = ast::synthNode(arena, ast::NodeValue::Block(ast::Block { statements: bodyStmts }));

    // Build: `fn #testMain() -> i32`

    let fnName = ast::synthNode(arena, ast::NodeValue::Ident(strings::intern(&mut STRING_POOL, "#testMain")));

    let returnType = ast::synthNode(arena, ast::NodeValue::TypeSig(ast::TypeSig::Integer {

        width: 4, sign: ast::Signedness::Signed,

    }));

    let fnSig = ast::FnSig {

        params: ast::nodeSlice(arena, 0),

        returnType,

        throwList: ast::nodeSlice(arena, 0),

    };

    // `@default` attribute.

    let attrNode = ast::synthNode(arena, ast::NodeValue::Attribute(ast::Attribute::Default));

    let attrList = ast::nodeSlice(arena, 1).append(attrNode, a);

    let fnAttrs = ast::Attributes { list: attrList };

    return ast::synthNode(arena, ast::NodeValue::FnDecl(ast::FnDecl {

        name: fnName, sig: fnSig, body: fnBody, attrs: fnAttrs,

    }));

}

/// Append a declaration to a block node's statement list.

fn injectIntoBlock(

    blockNode: *mut ast::Node,

    arena: *mut ast::NodeArena,

    decl: *ast::Node

) {

    let case ast::NodeValue::Block(block) = blockNode.value else {

        panic "injectIntoBlock: expected Block node";

    };

    let stmts = block.statements.append(decl, alloc::arenaAllocator(&mut arena.arena));

    blockNode.value = ast::NodeValue::Block(ast::Block { statements: stmts });

}

/// Write code buffer to file as raw bytes.

fn writeCode(code: *[u32], path: *[u8]) -> bool {

    // Convert `u32` slice to `u8` slice (little-endian).

    let byteLen = code.len * 4;

    let bytePtr = code.ptr as *u8;

    let bytes = @sliceOf(bytePtr, byteLen);

    return unix::writeFile(path, bytes);

}

/// Write a data section to a file at `basePath` + `ext`.

/// If the data is empty, no file is written.

fn writeDataWithExt(

    data: *[u8],

    basePath: *[u8],

    ext: *[u8]

) throws (Error) {

    if data.len == 0 {

        return;

    }

    let mut path: [u8; MAX_PATH_LEN] = undefined;

    let mut pos: u32 = 0;

    pos += try! mem::copy(&mut path[pos..], basePath);

    pos += try! mem::copy(&mut path[pos..], ext);

    path[pos] = 0; // Null-terminate for syscall.

    if not unix::writeFile(&path[..pos], data) {

        io::printError("radiance: fatal: failed to write data file\n");

        throw Error::Other;

    }

}

/// Serialize debug entries and write the `.debug` file.

/// Resolves module IDs to file paths via the module graph.

/// Format per entry is `{pc: u32,  offset: u32, filePath: [u8], NULL}`.

fn writeDebugInfo(

    entries: *[types::DebugEntry],

    graph: *module::ModuleGraph,

    basePath: *[u8],

    arena: *mut alloc::Arena

) throws (Error) {

    if entries.len == 0 {

        return;

    }

    // Use remaining arena space as serialization buffer.

    let buf = alloc::remainingBuf(arena);

    let mut pos: u32 = 0;

    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";

        };

        pos += try! mem::copy(&mut buf[pos..], @sliceOf(&entry.pc as *u8, 4));

        pos += try! mem::copy(&mut buf[pos..], @sliceOf(&entry.offset as *u8, 4));

        pos += try! mem::copy(&mut buf[pos..], modEntry.filePath);

        buf[pos] = 0;

        pos += 1;

    }

    try writeDataWithExt(&buf[..pos], basePath, DEBUG_EXT);

}

/// 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[..]);

    let entryPkg = try getEntryPackage(ctx);

    pkgLog(entryPkg, &["resolving", ".."]);

    let nodeDataSize = nodeCount * @sizeOf(resolver::NodeData);

    let nodeDataPtr = try! alloc::alloc(&mut mainArena, nodeDataSize, @alignOf(resolver::NodeData));

    let nodeData = @sliceOf(nodeDataPtr as *mut resolver::NodeData, nodeCount);

    let storage = resolver::ResolverStorage {

        arena: mainArena,

        nodeData,

        pkgScope: &mut RESOLVER_PKG_SCOPE,

        errors: &mut RESOLVER_ERRORS[..],

    };

    let mut res = resolver::resolver(storage, ctx.config);

    // Build package inputs.

    let mut packages: [resolver::Pkg; MAX_PACKAGES] = undefined;

    for i in 0..ctx.packageCount {

        let pkg = &ctx.packages[i];

        let root = try getRootModule(pkg, &ctx.graph);

        packages[i] = resolver::Pkg {

            rootEntry: root.entry,

            rootAst: root.ast,

        };

    }

    // Resolve all packages.

    // TODO: Fix this error printing dance.

    let diags = try resolver::resolve(&mut res, &ctx.graph, &packages[..ctx.packageCount]) catch {

        let diags = resolver::Diagnostics { errors: res.errors };

        resolver::printer::printDiagnostics(&diags, &res);

        throw Error::Other;

    };

    if not resolver::success(&diags) {

        resolver::printer::printDiagnostics(&diags, &res);

        io::print("radiance: failed: ");

        io::printU32(diags.errors.len);

        io::printLn(" errors");

        throw Error::Other;

    }

    return res;

}

/// Lower, optionally dump, and optionally generate binary output.

fn compile(ctx: *mut CompileContext, res: *mut resolver::Resolver) throws (Error) {

    let entryPkg = try getEntryPackage(ctx);

    // Lower all packages into a single unified IL program.

    // Dependencies must be lowered before the packages that use them.

    let program = try lowerAllPackages(ctx, res);

    let mut out = sexpr::Output::Stdout;

    if ctx.dump == Dump::Il {

        il::printer::printProgram(&mut out, &mut res.arena, &program);

        io::print("\n");

        return;

    }

    if ctx.dump == Dump::Asm {

        // TODO: Why do we generate code in two places?

        let result = rv64::generate(&program, rv64::Storage { dataSyms: &mut CODEGEN_DATA_SYMS[..], dataSymEntries: &mut CODEGEN_DATA_SYM_ENTRIES[..] }, &mut RO_DATA_BUF[..], &mut RW_DATA_BUF[..], &mut res.arena, false);

        printer::printCodeTo(&mut out, entryPkg.name, result.code, result.funcs, &mut res.arena);

        io::print("\n");

        return;

    }

    // Generate binary output if path specified.

    let outPath = ctx.outputPath else {

        return;

    };

    // Check that we have an entry point.

    if program.defaultFnIdx == nil {

        io::printError("radiance: fatal: no default function found\n");

        throw Error::Other;

    }

    pkgLog(entryPkg, &["generating code", "(", outPath, ")", ".."]);

    let storage = rv64::Storage { dataSyms: &mut CODEGEN_DATA_SYMS[..], dataSymEntries: &mut CODEGEN_DATA_SYM_ENTRIES[..] };

    let result = rv64::generate(&program, storage, &mut RO_DATA_BUF[..], &mut RW_DATA_BUF[..], &mut res.arena, ctx.debug);

    if not writeCode(result.code, outPath) {

        io::printError("radiance: fatal: failed to write output file\n");

        throw Error::Other;

    }

    // Write data files.

    try writeDataWithExt(&RO_DATA_BUF[..result.roDataSize], outPath, RO_DATA_EXT);

    try writeDataWithExt(&RW_DATA_BUF[..result.rwDataSize], outPath, RW_DATA_EXT);

    // Write debug info file if enabled.

    if ctx.debug {

        try writeDebugInfo(result.debugEntries, &ctx.graph, outPath, &mut res.arena);

    }

    pkgLog(entryPkg, &["ok", "(", outPath, ")"]);

}

@default fn main(env: *sys::Env) -> i32 {

    let mut arena = ast::nodeArena(&mut TEMP_ARENA[..]);

    let mut ctx = try processCommand(env.args, &mut arena) catch {

        return 1;

    };

    match ctx.dump {

        case Dump::Ast => {

            try dumpAst(&ctx) catch {

                return 1;

            };

            return 0;

        }

        case Dump::Graph => {

            dumpGraph(&ctx);

            return 0;

        }

        else => {}

    }

    // Generate test runner if in test mode.

    if ctx.config.buildTest {

        try generateTestRunner(&mut ctx, &mut arena) catch {

            return 1;

        };

    }

    // Run resolution phase.

    let mut res = try runResolver(&mut ctx, arena.nextId) catch {

        return 1;

    };

    // Lower, dump, and/or generate output.

    try compile(&mut ctx, &mut res) catch {

        return 1;

    };

    return 0;

}