Manejo de Errores Semánticos en Lenguaje Platzi

Clase 48 de 58 • Curso de Creación de Lenguajes de Programación: Intérpretes

Resumen

¿Cómo manejar errores semánticos en un lenguaje de programación?

En el desarrollo de un lenguaje de programación, es crucial gestionar los errores de manera eficiente para asegurar la fluidez y funcionalidad del código. A diferencia de los errores tradicionales (como except o raise en Python), los errores semánticos tienen que ver con la lógica y el significado de las operaciones dentro del lenguaje que estás creando.

¿Qué es un error semántico?

Un error semántico ocurre cuando una declaración es sintácticamente correcta pero carece de un significado dentro del contexto del lenguaje. Por ejemplo:

¿Qué resulta de verdadero + falso?
O 5 entre "texto".

Estas operaciones no tienen sentido semántico y, por tanto, deben ser gestionadas correctamente para evitar la ejecución de código erróneo o sin sentido.

Implementación de manejo de errores

Para gestionar errores en tu lenguaje de programación, sigue esta estrategia:

Identifica las expresiones no válidas: Primero, escribe tests que evalúen las diferentes expresiones que no son válidas. Ejemplo:

# Este test busca detectar errores semánticos como 5 + verdadero
assert evaluate("5 + verdadero") == "Error: Tipo de datos no compatible"

Crea una clase de Error: Define una clase que represente los errores durante la evaluación. Por ejemplo:

class Error():
    def __init__(self, message):
        self.message = message
    
    def type(self):
        return "ERROR"
    
    def inspect(self):
        return f"ERROR: {self.message}"

Genera un helper newError: Facilita la creación de instancias de error. Esta función formatea el mensaje y detiene la ejecución cuando se presenta un error:
```
def newError(message, args):
    return Error(message.format(*args))
```
Detiene la ejecución al encontrar un error: Modifica tu evaluador para que, si detecta un error, detenga la ejecución del programa inmediatamente.

Modificación del evaluador para manejo de errores

En el evaluador del lenguaje, deberás adaptar las condiciones para manejar los errores eficientemente:

Verifica las operaciones del prefijo y sufijo: Maneja operaciones desconocidas retornando un error.

if un_recognized_prefix_operator:
    return newError("Operador de prefijo desconocido: {}", [operator])

Administra discrepancias de tipos: Si hay una discrepancia de tipos, reporta el error adecuadamente.

if left_type != right_type:
    return newError("Discrepancia de tipo: {} {} {}", [left_type, operator, right_type])

Evalúa correctamente un bloque o programa: Si un bloque contiene un error, o detén la ejecución adecuadamente.
```
if result_type in ["RETURN", "ERROR"]:
    return result
```

Mejorando el manejo de errores

Para un lenguaje de programación listo para producción, el error debería incluir:

Línea y columna del error
Stack trace completo

Estos detalles pueden ser capturados a medida que los tokens son evaluados, guardando su posición en el código fuente.

Reto avanzado

Finalmente, como un reto adicional, podrías modificar el objeto Error para integrar información de línea y columna, mejorando la precisión al informar errores. Esto requiere modificar los tokens para almacenar su posición en el código.

Este manejo de errores proporciona una base sólida para detectar fallas semánticas, permitiéndote construir un lenguaje que sea robusto y fácil de depurar. ¡Continúa explorando y mejorando tus habilidades en el desarrollo de lenguajes de programación!