feat(parser): simplify if/elif/else end syntax

RafaelLopes23 · RafaelLopes23 · commit 9028460bccbc · 2025-12-14T13:04:20.000-03:00
- Introduce  and update  and
  so entire if/elif/else chains are closed by a single .
- Adjust pretty printer () to format IfThenElse/IfChain with inner blocks
  and a single trailing .
- Refresh parser and pretty-print tests plus README examples to reflect the revised control-flow syntax.
- Confirm all unit tests pass with the new behavior.
diff --git a/README.md b/README.md
@@ -111,14 +111,14 @@ RPython uses explicit, static types for function parameters and return values. V
 ```text
 if score >= 90:
     grade = "A";
-end elif score >= 80:
+elif score >= 80:
     grade = "B";
-end else:
+else:
     grade = "C";
 end
 ```
 
-Each branch in an if-chain has its own block terminated by `end`. The `elif` and `else` keywords follow the preceding `end`.
+A single `end` closes the entire if-chain. The `elif` and `else` keywords introduce new branches without requiring separate `end` markers.
 
 ### Loops
 
@@ -147,7 +147,7 @@ Functions require type annotations for parameters and return type.
 def factorial(n: Int) -> Int:
     if n <= 1:
         return 1;
-    end else:
+    else:
         return n * factorial(n - 1);
     end;
 end;
diff --git a/examples/hello_io.rpy b/examples/hello_io.rpy
@@ -45,11 +45,11 @@ val score = 85;
 var _ = print("Score 85 gets grade: ");
 if score >= 90:
     var _ = print_line("A");
-end elif score >= 80:
+elif score >= 80:
     var _ = print_line("B");
-end elif score >= 70:
+elif score >= 70:
     var _ = print_line("C");
-end else:
+else:
     var _ = print_line("F");
 end;
 
@@ -89,9 +89,9 @@ var _ = print("Skip evens: ");
 for k in [0, 1, 2, 3, 4, 5]:
     if k == 0:
         continue;
-    end elif k == 2:
+    elif k == 2:
         continue;
-    end elif k == 4:
+    elif k == 4:
         continue;
     end;
     var _ = print(k);
@@ -103,7 +103,7 @@ var _ = print_line("=== 9. Functions ===");
 def factorial(n: Int) -> Int:
     if n <= 1:
         return 1;
-    end else:
+    else:
         return n * factorial(n - 1);
     end;
 end;
diff --git a/src/parser/parser_stmt.rs b/src/parser/parser_stmt.rs
@@ -124,13 +124,11 @@ fn parse_if_else_statement(input: &str) -> IResult<&str, Statement> {
         tuple((
             keyword(IF_KEYWORD),
             preceded(multispace0, parse_expression),
-            parse_block,
-            opt(preceded(
-                tuple((multispace0, keyword(ELSE_KEYWORD))),
-                parse_block,
-            )),
+            parse_inner_block,
+            opt(preceded(keyword(ELSE_KEYWORD), parse_inner_block)),
+            preceded(multispace0, keyword(END_KEYWORD)),
         )),
-        |(_, cond, then_block, else_block)| {
+        |(_, cond, then_block, else_block, _)| {
             Statement::IfThenElse(
                 Box::new(cond),
                 Box::new(then_block),
@@ -143,13 +141,14 @@ fn parse_if_else_statement(input: &str) -> IResult<&str, Statement> {
 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 (input_after_block, block_if) = parse_inner_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);
+        let result =
+            tuple((keyword(ELIF_KEYWORD), parse_expression, parse_inner_block))(current_input);
         match result {
             Ok((next_input, (_, cond_elif, block_elif))) => {
                 branches.push((Box::new(cond_elif), Box::new(block_elif)));
@@ -158,9 +157,11 @@ pub fn parse_if_chain_statement(input: &str) -> IResult<&str, Statement> {
             Err(_) => break,
         }
     }
-    let (input, else_branch) = opt(preceded(keyword(ELSE_KEYWORD), parse_block))(current_input)?;
+    let (input_after_else, else_branch) =
+        opt(preceded(keyword(ELSE_KEYWORD), parse_inner_block))(current_input)?;
+    let (input_final, _) = preceded(multispace0, keyword(END_KEYWORD))(input_after_else)?;
     Ok((
-        input,
+        input_final,
         Statement::IfChain {
             branches,
             else_branch: else_branch.map(Box::new),
@@ -412,6 +413,31 @@ pub fn parse_block(input: &str) -> IResult<&str, Statement> {
     )(input)
 }
 
+/// Parses a block without consuming `end`. Used for if/elif/else branches
+/// where only the final `end` closes the entire construct.
+pub fn parse_inner_block(input: &str) -> IResult<&str, Statement> {
+    map(
+        tuple((
+            char::<&str, Error<&str>>(COLON_CHAR),
+            multispace0,
+            separated_list0(
+                delimited(
+                    multispace0,
+                    char::<&str, Error<&str>>(SEMICOLON_CHAR),
+                    multispace0,
+                ),
+                parse_statement,
+            ),
+            opt(preceded(
+                multispace0,
+                char::<&str, Error<&str>>(SEMICOLON_CHAR),
+            )),
+            multispace0,
+        )),
+        |(_, _, stmts, _, _)| Statement::Block(stmts),
+    )(input)
+}
+
 pub fn parse_formal_argument(input: &str) -> IResult<&str, FormalArgument> {
     map(
         tuple((
@@ -552,7 +578,8 @@ mod tests {
         assert_eq!(parsed_if_only, expected_if_only);
 
         // Cenário 2: Um "if" com "else", mas sem "elif".
-        let input_if_else = "if False: x = 1; end else: y = 2; end";
+        // New syntax: only one `end` at the very end
+        let input_if_else = "if False: x = 1; else: y = 2; end";
         let expected_if_else = Statement::IfChain {
             branches: vec![(
                 Box::new(Expression::CFalse),
@@ -570,7 +597,8 @@ mod tests {
         assert_eq!(parsed_if_else, expected_if_else);
 
         // Cenário 3: "if", um "elif", e um "else".
-        let input_if_elif_else = "if a: x = 1; end elif b: y = 2; end else: z = 3; end";
+        // New syntax: only one `end` at the very end
+        let input_if_elif_else = "if a: x = 1; elif b: y = 2; else: z = 3; end";
         let expected_if_elif_else = Statement::IfChain {
             branches: vec![
                 (
@@ -597,7 +625,8 @@ mod tests {
         assert_eq!(parsed_if_elif_else, expected_if_elif_else);
 
         // Cenário 4: "if" com múltiplos "elif" e sem "else".
-        let input_multi_elif = "if a: x=1; end elif b: y=2; end elif c: z=3; end";
+        // New syntax: only one `end` at the very end
+        let input_multi_elif = "if a: x=1; elif b: y=2; elif c: z=3; end";
         let expected_multi_elif = Statement::IfChain {
             branches: vec![
                 (
diff --git a/src/pretty_print/pretty_statements.rs b/src/pretty_print/pretty_statements.rs
@@ -12,6 +12,16 @@ fn join(sep: Rc<Doc>, docs: Vec<Rc<Doc>>) -> Rc<Doc> {
         .unwrap_or_else(nil)
 }
 
+/// Formats an inner block (without the trailing `end`).
+/// Used for if/elif/else branches where only one `end` closes the entire construct.
+fn inner_block_to_doc(stmts: &[Statement]) -> Rc<Doc> {
+    let stmts_doc: Vec<Rc<Doc>> = stmts.iter().map(|s| s.to_doc()).collect();
+    concat(
+        text(" :"),
+        nest(4, concat(hardline(), join(hardline(), stmts_doc))),
+    )
+}
+
 /// Implementa a conversão de nós de `Statement` da AST para a representação `Doc`.
 /// Cada variante do `enum Statement` é mapeada para um layout de formatação específico.
 impl ToDoc for Statement {
@@ -63,42 +73,80 @@ impl ToDoc for Statement {
                 )
             }
             // Formata estruturas `if-then-else`.
+            // Uses inner blocks (no `end`) and adds one `end` at the very end.
             Statement::IfThenElse(cond, then_branch, else_branch) => {
+                // Extract statements from the then block
+                let then_stmts = match then_branch.as_ref() {
+                    Statement::Block(stmts) => stmts,
+                    _ => return concat(text("if "), concat(cond.to_doc(), then_branch.to_doc())),
+                };
+
                 let mut doc = concat(
                     text("if "),
-                    concat(cond.to_doc(), concat(text(" "), then_branch.to_doc())),
+                    concat(cond.to_doc(), inner_block_to_doc(then_stmts)),
                 );
+
                 // Adiciona a cláusula `else` apenas se ela existir.
                 if let Some(else_b) = else_branch {
-                    doc = concat(doc, concat(text(" else "), else_b.to_doc()));
+                    let else_stmts = match else_b.as_ref() {
+                        Statement::Block(stmts) => stmts,
+                        _ => return concat(doc, concat(hardline(), text("end"))),
+                    };
+                    doc = concat(
+                        doc,
+                        concat(
+                            concat(hardline(), text("else")),
+                            inner_block_to_doc(else_stmts),
+                        ),
+                    );
                 }
-                doc
+                // Add the final `end`
+                concat(doc, concat(hardline(), text("end")))
             }
             // Cadeia de if/elif/else: branches: Vec<(cond, bloco)>, else_branch opcional
+            // Uses inner blocks and adds one `end` at the very end.
             Statement::IfChain {
                 branches,
                 else_branch,
             } => {
+                // Helper to extract statements from a block
+                fn get_stmts(block: &Statement) -> &[Statement] {
+                    match block {
+                        Statement::Block(stmts) => stmts,
+                        _ => &[],
+                    }
+                }
+
                 // Primeiro branch usa 'if', subsequentes usam 'elif'
                 let mut iter = branches.iter();
                 if let Some((first_cond, first_block)) = iter.next() {
+                    let first_stmts = get_stmts(first_block.as_ref());
                     let mut acc = concat(
                         text("if "),
-                        concat(first_cond.to_doc(), concat(text(" "), first_block.to_doc())),
+                        concat(first_cond.to_doc(), inner_block_to_doc(first_stmts)),
                     );
                     for (cond, block) in iter {
+                        let block_stmts = get_stmts(block.as_ref());
                         acc = concat(
                             acc,
                             concat(
-                                text(" elif "),
-                                concat(cond.to_doc(), concat(text(" "), block.to_doc())),
+                                concat(hardline(), text("elif ")),
+                                concat(cond.to_doc(), inner_block_to_doc(block_stmts)),
                             ),
                         );
                     }
                     if let Some(else_b) = else_branch {
-                        acc = concat(acc, concat(text(" else "), else_b.to_doc()));
+                        let else_stmts = get_stmts(else_b.as_ref());
+                        acc = concat(
+                            acc,
+                            concat(
+                                concat(hardline(), text("else")),
+                                inner_block_to_doc(else_stmts),
+                            ),
+                        );
                     }
-                    acc
+                    // Add the final `end`
+                    concat(acc, concat(hardline(), text("end")))
                 } else {
                     // Sem branches: devolve bloco vazio
                     text("")
diff --git a/tests/parser_tests.rs b/tests/parser_tests.rs
@@ -210,8 +210,8 @@ mod statement_tests {
         assert_eq!(rest, "");
         assert_eq!(result, expected);
 
-        // Test with else
-        let input = "if x > 0: y = 1; end else: y = 2; end";
+        // Test with else (new syntax: one `end` at the very end)
+        let input = "if x > 0: y = 1; else: y = 2; end";
         let expected = Statement::IfThenElse(
             Box::new(Expression::GT(
                 Box::new(Expression::Var("x".to_string())),
