Pruebas de AST para Let y Return Statements en Parsers

Curso de Creación de Lenguajes de Programación: Intérpretes

Contenido del curso

Introducción al desarrollo de intérpretes y lenguajes de programación

Construcción del lexer o tokenizador

Construcción del parser o analizador sintáctico

Evaluación o análisis semántico

Mejora del intérprete

Siguientes pasos

Tomar examen

Cursos Empresas Blog Live Conf Eventos Precios

0:0012:05

Pruebas de AST para Let y Return Statements en Parsers

Curso de Creación de Lenguajes de Programación: Intérpretes

Clase 20 de 58

Clase 20 / 58

Recursos

Cuando construimos un parser, no basta con saber que reconoce sentencias correctamente. También necesitamos verificar que la estructura de datos interna —el AST— sea exactamente la que esperamos. Esta técnica complementaria permite construir manualmente el árbol de sintaxis abstracta y compararlo con el programa que el parser debería generar, ofreciendo una visión clara de cómo se representan las instrucciones en memoria.

¿Qué significa probar el AST de forma inversa?

Hasta ahora, las pruebas del parser partían de un string con código fuente y verificaban que se generara cierta estructura. La técnica que se presenta aquí invierte ese flujo: se construye primero el AST con sus nodos y luego se compara contra el string que esa estructura debería producir [01:20].

Esto es posible porque cada nodo del AST implementa el método __str__ (dunder string), que define su representación textual. Al llamar str(program), Python recorre el árbol y devuelve el programa original reconstruido.

Se construye una instancia de Program con su lista de statements.
Se compara el resultado de str(program) con el código esperado.
Si no coinciden, el test falla y sabemos exactamente dónde está el problema.

¿Cómo se estructura un test para el let statement?

Para preparar el archivo de pruebas, se crea ast_test.py dentro del folder de tests [02:30]. Los imports necesarios son:

TestCase del módulo unittest.
Identifier, LetStatement y Program del módulo lpp/ast.
Token y TokenType del módulo lpp/token.

El programa que se quiere representar es variable mi_var = otra_variable;. Para construir este AST manualmente, el nodo raíz es un Program, que contiene una lista de statements [03:45].

¿Qué nodos componen un let statement?

Un LetStatement requiere tres elementos:

Un token de tipo TokenType.LET con literal "variable".
Un name que es un Identifier, inicializado con un token de tipo TokenType.IDENT y literal "mi_var", cuyo valor también es "mi_var".
Un value que en este caso es otro Identifier, con token de tipo TokenType.IDENT, literal "otra_variable" y valor "otra_variable" [05:10].

El value de un LetStatement puede ser cualquier expresión: un entero, una función o, como en este ejemplo, otro identificador. Esa flexibilidad es fundamental para representar asignaciones complejas.

¿Cómo se ejecuta la verificación?

Una vez armado el árbol, se convierte a string y se compara:

python program_str = str(program) self.assertEqual(program_str, 'variable mi_var = otra_variable;')

Si se modifica el string esperado, por ejemplo añadiendo un carácter de negación, el test falla inmediatamente, confirmando que el AST solo produce la representación exacta del programa original [07:00].

¿Cómo se ve la estructura completa del árbol?

La jerarquía resultante es clara:

Program → contiene una lista de statements.
- LetStatement → tiene un token (let), un name (Identifier) y un value (expresión).
  - Identifier (name) → token de tipo IDENT, valor "mi_var".
  - Identifier (value) → token de tipo IDENT, valor "otra_variable".

Si el programa tuviera más instrucciones, simplemente se agregarían más elementos a la lista de statements. Por ejemplo, un ReturnStatement sería otro nodo dentro de esa misma lista [08:30].

Esta forma de visualizar el AST refuerza un concepto importante: el parser transforma texto plano en una estructura de datos jerárquica que luego puede ser evaluada, optimizada o transformada.

El reto propuesto consiste en implementar la prueba equivalente para un ReturnStatement, aplicando exactamente la misma lógica: construir el árbol, convertirlo a string y verificar que coincida con el código fuente esperado. Comparte tu solución y cualquier duda en los comentarios para enriquecer el proceso de aprendizaje colectivo.

Carlos Eduardo Gomez García

Hace 6 años

Listo, para mi test lo único que hice fue moduificar el mismo test de let jajaja, pero únicamente cambié el token que debería regresar y su return value:

def test_return_statement(self) -> None:

        program: Program = Program(statements=[

            ReturnStatement(

                token=Token(TokenType.RETURN, literal="regresa"),

                return_value=Identifier(
                    token=Token(TokenType.IDENT, literal="mi_var"),
                    value="mi_var"
                )

            )

        ])

        program_str = str(program)
        self.assertEquals(program_str, "regresa mi_var;")

En este caso, el return_value de la clase ReturnStatement recibe una expresion,pero como la clase Identifier extiende de la misma clase Expresion entonces puedo pasarle un Identifier sin problemas :D

Victor Alexander De Jesus De Nobrega

Hace 5 años

Si eso de Identifier es gracias a la herencia y al polimorfismo (y que Python es muy laxo con los tipos de datos de referencia, pero detalles esta bien escrito y por esto no hay que preocuparse en este caso). Quisiera agregar que me di cuenta en estos 2 test importa poco el tipo de TokenType que se asigne lo que importa es el valor de literal. Yo tenia puesto LET en vez de RETURN en el token

Introducción al desarrollo de intérpretes y lenguajes de programación

Construcción de Intérpretes de Software en Python 3.8

Creación de Compiladores e Intérpretes con Lenguaje Platzi

Construcción del lexer o tokenizador

Análisis Léxico: Construcción de un Léxer para Intérpretes

Definición de Tokens en Lenguaje de Programación Platzi

Desarrollo de un Lexer con Test-Driven Development

Pruebas de Operadores, Delimitadores y Fin de Archivo en Lexer Python

Lexer: Identificación de Keywords y Tokens Complejos

Reconocimiento de Funciones en Lexer de Lenguaje de Programación

Implementación de Operadores y Condicionales en Lexer de Platzi

Implementación de Operadores de Dos Caracteres en Lexer

Creación de un REPL en Python para Lenguaje de Programación

Construcción del parser o analizador sintáctico

Construcción de un Parser para el Lenguaje Platzi

Definición de Nodos Abstractos para Árbol de Sintaxis (AST) en Python

Desarrollo de un AST en Python: Creación de la Clase Programa

Parseo de Let Statements en Lenguaje Platzi

Implementación de funciones advanced y expected tokens

Manejo de Errores en Parsers con Test Driven Development

Parseo de Return Statements en Lenguaje Platzi

Técnicas de Parsing: Top-Down y Bottom-Up

Pruebas de AST para Let y Return Statements en Parsers

Pratt Parsing: Implementación y Registro de Funciones en Python

Parseo de Identificadores en Lenguajes de Programación

Parseo de Expression Statements en Platzi Parser

Parseo de Enteros en Lenguaje Platzi

Implementación de Operadores Prefijo en Parsers

Operadores InFix en Expresiones: Implementación y Pruebas

Implementación de Operadores InFix en un Parser

Expresiones Booleanas en el Lenguaje de Programación Platzi

Evaluación de Precedencia y Testeo de Booleanos en Parsers

Evaluación de Expresiones Agrupadas en un Parser

Parseo de Condicionales en Lenguaje Platzi

Implementación de Condicionales en Parser de Lenguaje

Parsing de Funciones en Lenguaje Platzi: Creación de Nodos AST

Construcción de nodos de función en un parser AST

Llamadas a Funciones en Lenguajes de Programación

Implementación de llamadas a funciones en un parser con AST

Parseo de Expresiones en LET y RETURN Statements

Implementación de REPL para Árbol de Sintaxis Abstracta

Evaluación o análisis semántico

Evaluación Semántica en Lenguajes de Programación

Estrategias de Evaluación en Lenguajes de Programación

Representación de Nodos AST y Objetos en Python

Evaluación de Expresiones en JavaScript y Python

Implementación del Patrón Singleton para Booleanos y Nulos

Evaluación de Prefijos en Lenguaje de Programación Platzi

Evaluación de Expresiones Infix en Lenguaje Platzi

Evaluación de Condicionales en Lenguaje de Programación Platzi

Evaluación y Uso del Return Statement en Programación

Manejo de Errores Semánticos en Lenguaje Platzi

Declaración y Gestión de Variables en Lenguajes de Programación

Manejo de Ambientes y Variables en Lenguajes de Programación

Declaración de Funciones en Lenguaje de Programación Platzi

Implementación de Llamadas a Funciones en PlatziLang

Mejora del intérprete

Implementación de Strings en un Intérprete de Lenguaje de Programación

Operaciones de Concatenación y Comparación de Strings en Intérprete

Implementación de Funciones Built-in en Python

Implementación de Built-ins en el Lenguaje Platzi

Siguientes pasos

Desarrollo de Lenguaje de Programación y Estructuras de Datos en Python

Construcción de un Intérprete en Python desde Cero

Pruebas de AST para Let y Return Statements en Parsers