Sistema de modulos

Sounio organiza el codigo en modulos. Un archivo puede declararse como modulo con una sentencia module explicita, o permanecer en el namespace plano si no hay declaracion presente.

Declarar un modulo

// file: ir/profile.sio
module ir::profile

fn sprof_parse(data: &str) -> SprofProfile {
    // ...
}

fn sprof_lookup(profile: &SprofProfile, name: &str) -> i64 {
    // ...
}

La declaracion module ir::profile coloca todas las definiciones de este archivo bajo el namespace ir::profile.

Importar desde modulos

Usa use para traer nombres al scope:

// Wildcard import — brings all public names into scope
use ir::profile::*

// The functions are now available directly
let profile = sprof_parse(data)
let count = sprof_lookup(profile, "main")

Tambien se soportan importaciones selectivas:

use ir::profile::{sprof_parse, sprof_lookup}

Importante: Las importaciones con wildcard (use module::*) son actualmente mas confiables que las selectivas para modulos que tienen funciones auxiliares internas. Algunas funciones auxiliares internas pueden fallar al resolverse con importaciones selectivas — se recomienda usar wildcard en caso de duda.

Archivos en namespace plano

Los archivos sin declaracion module estan en el namespace plano. Sus definiciones estan disponibles directamente para cualquier archivo que pueda verlos, sin necesidad de una sentencia use explicita:

// file: ir/normalize.sio
// (no module declaration)

fn normalize_instruction(instr: &!IrInstr) {
    // available without import in other flat-namespace files
}

Archivos como normalize.sio, const_prop.sio, dce.sio y ssa.sio en el compilador self-hosted usan este patron.

Reglas de resolucion de modulos

1. Un archivo con module X::Y debe importarse con use X::Y::* o use X::Y::{nombre}.
2. Un archivo sin module esta en el namespace plano — sus nombres son visibles sin importaciones.
3. Las referencias hacia adelante (forward references) no estan soportadas: las funciones auxiliares deben definirse antes que las funciones que las llaman en el archivo fuente.
4. Las rutas de modulo corresponden a rutas del sistema de archivos: module ir::profile corresponde a ir/profile.sio.

Combinar modulos y archivos planos

El compilador self-hosted mezcla ambos patrones:

// main.sio — uses both module and flat-namespace imports
use ir::ir::*           // module import: IrFunction, IrModule, etc.
use ir::profile::*      // module import: SprofProfile, sprof_parse, etc.
use ir::inline::*       // module import: inl_run_pass, etc.

// normalize.sio, const_prop.sio are flat — no import needed

Guia practica

• Usa module para bibliotecas y componentes reutilizables con interfaces claras.
• Usa namespace plano para archivos de implementacion estrechamente acoplados que comparten muchas funciones auxiliares internas.
• Siempre usa use parser::ast::* (wildcard) al importar tipos del AST — las importaciones selectivas pueden romper las comparaciones de operadores en variantes de enum.