Índice

Apéndice C: Mensajes de error comunes

Este apéndice lista los errores más comunes que encontrarás al programar en Nyx, junto con sus causas y soluciones.

Errores de tipo

"Type mismatch: expected X, got Y"

Estás usando un valor del tipo incorrecto donde se espera un tipo específico.

// Error: Type mismatch: expected int, got String
let x: int = "hola"

// Solución: usa el tipo correcto
let x: String = "hola"
// O convierte:
let x: int = string_to_int("42")

"Cannot assign to immutable variable"

Declaraste una variable con let (inmutable) e intentaste cambiarla.

// Error: Cannot assign to immutable variable 'x'
let x: int = 10
x = 20

// Solución: usa 'var' para variables mutables
var x: int = 10
x = 20

"Undefined variable: X"

Estás usando una variable que no ha sido declarada en el scope actual.

// Error: Undefined variable: count
print(int_to_string(count))

// Solución: declara la variable primero
var count: int = 0
print(int_to_string(count))

"Undefined function: X"

Estás llamando a una función que no existe o no ha sido importada.

// Error: Undefined function: json_parse
let data: Map = json_parse(text)

// Solución: importa el módulo que define la función
import "std/json"
let data: Map = json_parse(text)

Errores de sintaxis

"Expected '{' after ..."

Nyx requiere llaves para todos los bloques — no hay atajos de una línea.

// Error: Expected '{' after if condition
if x > 0
    print("positivo")

// Solución: agrega llaves
if x > 0 {
    print("positivo")
}

"Expected type annotation"

Los parámetros de función requieren tipos explícitos.

// Error: Expected type annotation
fn add(a, b) {
    return a + b
}

// Solución: agrega anotaciones de tipo
fn add(a: int, b: int) -> int {
    return a + b
}

"Unexpected token"

El parser encontró algo que no esperaba. Causas comunes:

// Error: Unexpected token
struct Point {
    x: int
    y: int
}

// Solución: agrega comas entre campos
struct Point {
    x: int,
    y: int
}

Errores de runtime

"Index out of bounds"

Estás accediendo a un array con un índice demasiado grande o negativo.

let arr: Array = [1, 2, 3]
// Error de runtime: Index out of bounds (index 5, length 3)
let x: int = arr[5]

// Solución: verifica la longitud primero
if index < arr.length() {
    let x: int = arr[index]
}

"Division by zero"

// Error de runtime: Division by zero
let result: int = 10 / 0

// Solución: verifica el divisor
if divisor != 0 {
    let result: int = 10 / divisor
}

"Key not found"

Accediendo a una clave de Map que no existe.

let m: Map = Map.new()
// Error de runtime: key not found
let v: String = m.get("faltante")

// Solución: verifica primero con .contains()
if m.contains("faltante") {
    let v: String = m.get("faltante")
}

"Null pointer / segmentation fault"

Esto usualmente significa:

  1. Llamaste a .charAt() y comparaste el resultado con un string en vez de un int
  2. Usaste un puntero después de liberarlo (en código unsafe)
  3. Accediste a un campo de struct sobre una referencia null
// Bug: charAt retorna int (valor ASCII), NO un string
let ch: int = name.charAt(0)
if ch == "A" { }    // MAL — comparando int con String → crash

// Solución: compara con valor ASCII
if ch == 65 { }     // 65 es ASCII para 'A'

Errores de import

"Module not found: X"

El compilador no puede encontrar el módulo que estás importando.

// Error: Module not found: utils
import "utils"

// Solución: verifica la ruta. Archivos locales necesitan la ruta relativa correcta:
import "src/utils"
// La biblioteca estándar usa prefijo std/:
import "std/json"

"Circular import detected"

Dos módulos se importan mutuamente, creando un ciclo.

// a.nx: import "b"
// b.nx: import "a"    ← ¡circular!

// Solución: reestructura. Extrae código compartido a un tercer módulo:
// common.nx: definiciones compartidas
// a.nx: import "common"
// b.nx: import "common"

Errores de match

"Non-exhaustive match"

Tu match no cubre todos los casos posibles.

enum Color { Red, Green, Blue }

// Error: Non-exhaustive match — missing: Blue
match color {
    Red => print("rojo"),
    Green => print("verde")
}

// Solución: agrega el caso faltante, o usa un comodín
match color {
    Red => print("rojo"),
    Green => print("verde"),
    _ => print("otro")
}

Errores de struct

"Unknown field: X"

Estás accediendo a un campo que no existe en el struct.

struct Point { x: int, y: int }
let p: Point = Point { x: 1, y: 2 }

// Error: Unknown field: z
print(int_to_string(p.z))

// Solución: usa un campo que exista
print(int_to_string(p.x))

"Missing field: X in struct initializer"

Olvidaste inicializar un campo requerido.

struct Point { x: int, y: int }

// Error: Missing field: y
let p: Point = Point { x: 1 }

// Solución: proporciona todos los campos
let p: Point = Point { x: 1, y: 2 }

Errores de concurrencia

"Channel closed" / retorno negativo de channel_recv

El channel ha sido cerrado o es inválido.

let ch: Map = channel_new(4)
// Si channel_recv retorna un valor negativo, el channel está cerrado
let val: int = channel_recv(ch)
if val < 0 {
    print("Channel cerrado")
}

Deadlock (el programa se cuelga)

Causas comunes:

// Deadlock: main envía pero nadie recibe
let ch: Map = channel_new(1)
channel_send(ch, 1)
channel_send(ch, 2)    // se bloquea — channel lleno, sin receptor

// Solución: crea un receptor con spawn, o aumenta la capacidad del channel

Errores de codegen / LLVM

"La función handler crashea" (problema conocido)

No uses handler como nombre de función — conflicta con el codegen interno.

// CRASHEA el compilador
fn handler(req: Array) -> String { ... }

// Solución: usa un nombre diferente
fn request_handler(req: Array) -> String { ... }
fn on_request(req: Array) -> String { ... }

Consejos generales de debugging

  1. Lee el mensaje de error cuidadosamente. Los mensajes de error de Nyx incluyen el número de línea y una descripción del problema.
  1. Compila con salida IR. Usa make compile FILE=prog.nx para ver el LLVM IR generado. Busca la función donde ocurre el error.
  1. Simplifica. Si un programa complejo falla, extrae la parte que falla a un archivo de test mínimo.
  1. Verifica los tipos. La mayoría de errores vienen de incompatibilidades de tipo. Recuerda:
  1. Verifica los imports. Si una función es "undefined," probablemente olvidaste importar su módulo.

← Volver al Índice

← Anterior: Apéndice B: Módulos de la biblioteca estándar Siguiente: Apéndice D: Glosario →