Vale, trataré de explicar con mis propias palabras este código para ver si entendí bien 🤔
.
Como dije en un aporte anterior, parse_program es el que se encargará de empezar a crear nuestro AST, primero creará el nodo principal (el programa) que básicamente es un wrapper de todos nuestros staments, básicamente un statement es cada acción de nuestro programa, por ejemplo, el conjunto de palabras que declaran una variable: variable platzi = 10; eso sería un statement.
.
Después de inicializar el programa, parse_program empezará a buscar los diferentes tokens (recordemos que aquí ya hablamos de tokens porque el Lexer que hicimos ya nos está dando los tokens de nuestro programa)
.
La condición de: while self._current_token.token_type != TokenType.EOF lo único que está diciendo es que mientras aún hayan tokens, se va a mandar a generar un statement. Básicamente sabemos que el token que finaliza nuestro programa es el EOF (End Of File).
.
Ahora, hablando de la generación de statements dentro de la función parse_statement... en primera, dentro de nuestro programa podemos tener varios tipos de statements (aunque según el profesor, dentro de LPP solo habrán dos), un ejemplo de ellos son los let statements (o statements de declaración de variables para que se entienda), es por eso que verificamos que si el token actual es LET significa que el usuario quiere declarar una variable, así que tenemos que empezar a verificar que la sintaxis de declaración sea correcta, pero esa tarea se la delegamos a _parse_let_satatement.
.
Entonces, básicamente _parse_let_satatement obtiene una instancia de la clase LetStatement (ubicada en ast.py) y empieza a validar, en teoría, la función _expected_token debería determinar cuál es el siguiente token que arrojó el Lexer y comparar si el token arrojado es un IDENT (recordemos que el token define el nombre de la variable, en el statement , platzi sería el token ).
.
En dado caso que el token no sea un significa que hay un error de sintaxis, por ahora devolvemos "None", esto provocará que retorne None y a su vez, dentro de la variable que está dentro del while acabará siendo None, por lo que por la condición que está debajo no dejará que este statement mal programado entre a la lista de statements de nuestro programa :D
.
En dado caso que el expected token sí haya sido un IDENT, procederemos a crear una instancia de con este identificador, después seguimos revisando la sintaxis, después del identificador debe haber un "=", así que comparamos que el siguiente token sea uno de asignación, si no lo es, misma historia, hay un error de sintaxis así que retornamos None, si sí lo es, entonces continuamos revisando los tokens hasta que encontremos el ";"
.
Ya que todo se terminó de revisar correctamente, se retorna el statement, lo que provocará que retorne un statement provocando que dentro acabe retornándose un statement también, y debido a que este sí es un statement de verdad, el que está ahí sí dejará guardar ese statement dentro de nuestro Program :D
.
Así es como entiendo que funciona este código, traté de describirlo lo mejor posible xD
Recursos
Resumen
¿Cómo parsear 'let statements' en el lenguaje de programación Platzi?
En el proceso de crear nuestro propio lenguaje de programación, encontramos que hay dos tipos fundamentales de statements: los 'let statements' y los 'return statements'. Aquí, nos enfocaremos en entender cómo parsear los 'let statements', esenciales para asignar valores a variables. Imagina que el proceso completo se asemeja a la construcción de un árbol, donde el nodo principal es el programa que contiene varios 'statements'.
¿Qué estructura tiene un 'let statement'?
Un 'let statement' se compone de:
- Identificador: Corresponde al nombre de la variable, por ejemplo, 'x' en
let x = 5;. - Expresión: Es el valor asignado a la variable, que puede ser un número, un booleano, una función, entre otros.
Ahora bien, para crear un parser que interprete 'let statements', necesitamos definir ciertos nodos y realizar test específicos.
¿Cómo implementamos los nodos para 'let statements'?
- Definición de nodos: Debemos crear nodos de tipo 'let statement' e 'identifier'. Esto se logra extendiendo una clase base llamada 'statement'.
- Constructor: En el constructor del 'let statement', se recibe un token, un nombre opcional (identifier) y un valor opcional (expression).
Por ejemplo, un nodo 'let statement' se inicializa de la siguiente manera:
class LetStatement(Statement): def __init__(self, token, name=None, value=None): super().__init__(token) self.name = name self.value = value
¿Cómo llevar a cabo tests para 'let statements'?
Primero, creamos una función de test para verificar la correcta interpretación de los 'let statements'. La prueba inicializa un lexer y un parser con un programa de prueba:
def test_let_statements(): input_program = "let x = 5; let y = 10; let foobar = 838383;" lexer = Lexer(input_program) parser = Parser(lexer) program = parser.parse_program() assert len(program.statements) == 3
Con estos test, nos aseguramos de que nuestro parser reconoce correctamente los 'let statements' del programa de ejemplo y que estos son almacenados como nodos dentro del árbol de nuestro programa.
¿Cómo funciona el proceso de parsear 'let statements'?
Para parsear los 'let statements', es vital definir las funciones necesarias que verificarán la sintaxis correcta y reconocerán los tokens involucrados:
- Advance Tokens: Funciona como un iterador que avanza al siguiente token.
- Expected Token: Evalúa si el siguiente token es el esperado de acuerdo a la gramática. Por ejemplo, después de un identificador en un 'let statement', da por hecho que el siguiente debe ser un operador de asignación.
¿Cuáles son los pasos finales para asegurar la correcta interpretación?
- Parse Statement: Método que identifica si el token actual representa un 'let statement'.
- Parse Let Statement: Método específico para los 'let statements'. Evalúa si la estructura de tokens sigue la sintaxis prevista (ej.,
let x = 5;).
Por último, la implementación de estas funciones asegura que el parser maneje adecuadamente los errores y solo integre statements con la sintaxis correcta en el programa.
Recomendaciones y siguientes pasos
Al trabajar en el parseo de 'let statements', es crucial implementar técnicas de test driven development (TDD) para asegurar que tu código maneje todo tipo de escenarios. Anímate a explorar más allá y crea tus propios tests. Una vez dominado el parseo de 'let statements', el siguiente reto será integrar el manejo de expresiones complejas y profundizar en 'return statements'. ¡Adelante, tu lenguaje de programación te está esperando!