feat(parser): Implementa parser para if-elif-else e corrige função 'keyword'

[jm-236]

Responsáveis:

• João Marcelo Costa de Santana
• Gustavo Alencar Valadares
• Guilherme Delmonte

Mudanças feitas

Este PR introduz um parser mais robusto para estruturas condicionais na linguagem r-python, adicionando suporte completo para a cadeia if-elif-else, e corrige um bug encontrado na função keyword durante o desenvolvimento.

Principais Mudanças:

1. Novo Parser if-elif-else:

   • Adicionada a função parse_if_chain_statement que lida com if, múltiplos elifs e um else opcional.
   • A antiga função parse_if_else_statement foi mantida no código. No parser principal (parse_statement), a nova função é chamada antes da antiga para garantir que estruturas com elif sejam reconhecidas corretamente.
   • Código do novo Parser:

   pub fn parse_if_chain_statement(input: &str) -> IResult<&str, Statement> {
       
       let (input_after_if, _) = keyword(IF_KEYWORD)(input)?;
       let (input_after_expr, cond_if) = parse_expression(input_after_if)?;
       let (input_after_block, block_if) = parse_block(input_after_expr)?;
       
       let mut branches = vec![(Box::new(cond_if), Box::new(block_if))];
       let mut current_input = input_after_block;
   
       loop {
           let result = tuple((keyword(ELIF_KEYWORD), parse_expression, parse_block))(current_input);
           match result {
               Ok((next_input, (_, cond_elif, block_elif))) => {
                   branches.push((Box::new(cond_elif), Box::new(block_elif)));
                   current_input = next_input;
               }
               Err(_) => break,
           }
       }
       let (input, else_branch) = opt(preceded(keyword(ELSE_KEYWORD), parse_block))(current_input)?;
       Ok((
           input,
           Statement::IfChain {
               branches,
               else_branch: else_branch.map(Box::new),
           },
       ))
   }

2. Correção em keyword:

   • A implementação anterior da função keyword falhava ao tentar analisar uma palavra-chave seguida por outro identificador (ex: if True), o que impediu a execução inicial dos testes.
   • A lógica foi corrigida para o padrão peek(not(alphanumeric1)), garantindo que a palavra-chave seja reconhecida corretamente sem conflito com o código que a sucede. Com isso, conseguimos executar os testes para o novo parser com sucesso.
   • Antiga implementação:

   /// Parses a reserved keyword (e.g., "if") surrounded by optional spaces
       /// Fails if followed by an identifier character
       pub fn keyword<'a>(kw: &'static str) -> impl FnMut(&'a str) -> IResult<&'a str, &'a str> {
           terminated(
               delimited(multispace0, tag(kw), multispace0),
               not(peek(identifier_start_or_continue)),
           )
       }

   • Nova implementação:

   pub fn keyword<'a>(kw: &'static str) -> impl FnMut(&'a str) -> IResult<&'a str, &'a str> {
           delimited(
               multispace0, 
               terminated(
                   tag(kw), 
                   peek(not(alphanumeric1)), 
               ),
               multispace0, 
           )
   }

Testes:

Adicionado um novo conjunto de testes unitários para a função parse_if_chain_statement, cobrindo os cenários de if, if-else, if-elif e if-elif-else. Ao executá-los utilizando o comando cargo test, obtivemos sucesso.

Como Testar:

Basta rodar cargo test. Todos os testes devem passar.

Arquivos alterados

• src/ir/ast.rs
• src/parser/keywords.rs
• src/parser/parser_common.rs
• src/parser/parser_stmt.rs