Parseo de condicionales: implementación

<h4>Aquí les dejo mi solución al reto</h4>

1. Diseñe el test:

def test_if_else_expression(self) -> None:
	source: str = 'if x > y then {z} else {w}'
	# Aqui va el mismo codigo que en test_if_expression
        # Test alternative
        assert if_expression.alternative is not None
        self.assertIsInstance(if_expression.alternative, Block)
        self.assertEquals(len(if_expression.alternative.statements), 1)

        alternative_statement = cast(
            ExpressionStatement, if_expression.alternative.statements[0])
        assert alternative_statement.expression is not None
        self._test_identifier(alternative_statement.expression, 'w')

1. Luego implemente lo necesario para parsear else, en parser.py dentro de _parse_if al final antes de return, agregue:

if self._peek_token is not None:
            if self._peek_token.token_type == TokenType.ELSE:
                self._advance_tokens()

                if not self._expected_token(TokenType.LBRACE):
                    return None

                if_expression.alternative = self._parse_block()

La sintaxis de SigmaF es un poco diferente, pero la implementación es casi la misma que para LPP 😉

Vale, comparto mi solución:
.
Para los tests (para no repetir código y poder hacer más tests), lo que hice fue crear un helper llamado _test_block el cual testeará todo un bloque de código, le puedes pasar cuántos statements quieres testear y una lista de los identificadores que esperas que esos statements devuelvan, el número de identificadores pasados en la lista deben ser los mismos que el número de statements:

def _test_block(self,
                    block: Block,
                    statements_number,
                    expected_identifiers: List[str]) -> None:


        self.assertIsInstance(block, Block)
        self.assertEquals(len(block.statements), statements_number)
        self.assertEquals(len(expected_identifiers), len(block.statements))

        # Recorro cada statement junto a los expected identifiers
        for statement, identifier in zip(block.statements, expected_identifiers):

            statement = cast(ExpressionStatement, statement)

            assert statement.expression is not None
            self._test_identifier(statement.expression, identifier)

Una vez implementado eso, cambié mi test de if para usar este helper:

...
# Test consequence
assert if_expression.consequence is not None

# Aquí uso la helper function
self._test_block(if_expression.consequence, 1, ["z"]) 

# Test alternative
self.assertIsNone(if_expression.alternative)
...

Y para el test del else hice lo mismo:

def test_if_else_expression(self) -> None:

    source: str = 'si (a > b) { x } si_no { z; x; }'

    lexer: Lexer = Lexer(source)
    parser: Parser = Parser(lexer)

    program: Program = parser.parse_program()

    self._test_program_statements(parser, program, 1)

    # Test correct node types
    if_expression = cast(If, cast(ExpressionStatement, program.statements[0]).expression)
    self.assertIsInstance(if_expression, If)

    # Test condition
    assert if_expression.condition is not None

    self._test_infix_expression(cast(Expression, if_expression.condition), "a", ">", "b")

    # Test consequence
    assert if_expression.consequence is not None
    self._test_block(if_expression.consequence, 1, ["x"])

    # Test alternative
    assert if_expression.alternative is not None
    self._test_block(if_expression.alternative, 2, ["z", "x"])

Y para hacer que pase, lo único que hice fue que, en el parser.py pregunto si el siguiente token es un ELSE, (primero se pone el assert de peek_token porque este es opcional y luego mypy se quja 😄)
.
Si la condición del siguiente token para un ELSE se cumple, me muevo hacia ese token y verifico que el siguiente token sea una llave de apertura, si sí lo es, pues mandamos a parsear el bloque con la función que hicimos en esta clase jaja.
.
Después miré la solución del profesor y vi que llegamos a lo mismo xD. Juro que no miré el código del profesor antes de resolver el reto!

if_expression.consequence = self._parse_block()

# Estamos en el "}", si el siguiente token es el else, entonces lo parseamos
assert self._peek_token is not None
if self._peek_token.token_type == TokenType.ELSE:

    self._advance_tokens()
    # Si el siguiente token no es una llave de apertura, hay un error de sintaxis
    if not self._expected_token(TokenType.LBRACE):
        return None

    if_expression.alternative = self._parse_block()

return if_expression