Make control flow stmts use Stmt instead of List<Stmt> for their bodies.

compiler/qsc_qasm3/src/parser/ast.rs

@@ -317,7 +317,7 @@ pub enum StmtKind {
     Barrier(BarrierStmt),
     Box(BoxStmt),
     Break(BreakStmt),
-    Block(Box<Block>),
+    Block(Block),
     Cal(CalibrationStmt),
     CalibrationGrammar(CalibrationGrammarStmt),
     ClassicalDecl(ClassicalDeclarationStmt),
@@ -419,16 +419,16 @@ impl Display for DefCalStmt {
 pub struct IfStmt {
     pub span: Span,
     pub condition: Expr,
-    pub if_block: List<Stmt>,
-    pub else_block: Option<List<Stmt>>,
+    pub if_body: Stmt,
+    pub else_body: Option<Stmt>,
 }
 
 impl Display for IfStmt {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         writeln_header(f, "IfStmt", self.span)?;
         writeln_field(f, "condition", &self.condition)?;
-        writeln_list_field(f, "if_block", &self.if_block)?;
-        write_opt_list_field(f, "else_block", self.else_block.as_ref())
+        writeln_field(f, "if_body", &self.if_body)?;
+        write_opt_field(f, "else_body", self.else_body.as_ref())
     }
 }
 
@@ -1323,8 +1323,8 @@ pub struct DefStmt {
     pub span: Span,
     pub name: Box<Ident>,
     pub params: List<TypedParameter>,
-    pub body: Box<Block>,
-    pub return_type: Option<ScalarType>,
+    pub body: Block,
+    pub return_type: Option<Box<ScalarType>>,
 }
 
 impl Display for DefStmt {
@@ -1354,14 +1354,14 @@ impl Display for ReturnStmt {
 pub struct WhileLoop {
     pub span: Span,
     pub while_condition: Expr,
-    pub block: List<Stmt>,
+    pub body: Stmt,
 }
 
 impl Display for WhileLoop {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         writeln_header(f, "WhileLoop", self.span)?;
         writeln_field(f, "condition", &self.while_condition)?;
-        write_list_field(f, "block", &self.block)
+        write_field(f, "body", &self.body)
     }
 }
 
@@ -1371,7 +1371,7 @@ pub struct ForStmt {
     pub ty: ScalarType,
     pub identifier: Identifier,
     pub set_declaration: Box<EnumerableSet>,
-    pub block: List<Stmt>,
+    pub body: Stmt,
 }
 
 impl Display for ForStmt {
@@ -1380,7 +1380,7 @@ impl Display for ForStmt {
         writeln_field(f, "variable_type", &self.ty)?;
         writeln_field(f, "variable_name", &self.identifier)?;
         writeln_field(f, "iterable", &self.set_declaration)?;
-        write_list_field(f, "block", &self.block)
+        write_field(f, "body", &self.body)
     }
 }
 

compiler/qsc_qasm3/src/parser/stmt.rs

@@ -278,20 +278,22 @@ fn disambiguate_ident(s: &mut ParserContext, indexed_ident: IndexedIdent) -> Res
 #[allow(clippy::vec_box)]
 pub(super) fn parse_many(s: &mut ParserContext) -> Result<Vec<Box<Stmt>>> {
     many(s, |s| {
-        recovering(s, default, &[TokenKind::Semicolon], parse_block_or_stmt)
+        recovering(s, default, &[TokenKind::Semicolon], |s| {
+            parse_block_or_stmt(s).map(Box::new)
+        })
     })
 }
 
 /// Grammar: `LBRACE statementOrScope* RBRACE`.
-pub(super) fn parse_block(s: &mut ParserContext) -> Result<Box<Block>> {
+pub(super) fn parse_block(s: &mut ParserContext) -> Result<Block> {
     let lo = s.peek().span.lo;
     token(s, TokenKind::Open(Delim::Brace))?;
     let stmts = barrier(s, &[TokenKind::Close(Delim::Brace)], parse_many)?;
     recovering_token(s, TokenKind::Close(Delim::Brace));
-    Ok(Box::new(Block {
+    Ok(Block {
         span: s.span(lo),
         stmts: stmts.into_boxed_slice(),
-    }))
+    })
 }
 
 #[allow(clippy::unnecessary_box_returns)]
@@ -454,7 +456,7 @@ fn parse_def(s: &mut ParserContext) -> Result<StmtKind> {
     token(s, TokenKind::Open(Delim::Paren))?;
     let (exprs, _) = seq(s, arg_def)?;
     token(s, TokenKind::Close(Delim::Paren))?;
-    let return_type = opt(s, return_sig)?;
+    let return_type = opt(s, return_sig)?.map(Box::new);
     let body = parse_block(s)?;
     let kind = StmtKind::Def(DefStmt {
         span: s.span(lo),
@@ -605,7 +607,7 @@ fn parse_gatedef(s: &mut ParserContext) -> Result<StmtKind> {
     let ident = Box::new(prim::ident(s)?);
     let params = opt(s, gate_params)?.unwrap_or_else(Vec::new);
     let (qubits, _) = seq(s, prim::ident)?;
-    let body = parse_block(s)?;
+    let body = Box::new(parse_block(s)?);
     Ok(StmtKind::QuantumGateDefinition(QuantumGateDefinition {
         span: s.span(lo),
         ident,
@@ -1122,7 +1124,7 @@ fn case_stmt(s: &mut ParserContext) -> Result<SwitchCase> {
         s.push_error(Error::new(ErrorKind::MissingSwitchCaseLabels(s.span(lo))));
     }
 
-    let block = parse_block(s).map(|block| *block)?;
+    let block = parse_block(s)?;
 
     Ok(SwitchCase {
         span: s.span(lo),
@@ -1134,27 +1136,19 @@ fn case_stmt(s: &mut ParserContext) -> Result<SwitchCase> {
 /// Grammar: `DEFAULT scope`.
 fn default_case_stmt(s: &mut ParserContext) -> Result<Block> {
     token(s, TokenKind::Keyword(Keyword::Default))?;
-    parse_block(s).map(|block| *block)
+    parse_block(s)
 }
 
 /// Grammar: `statement | scope`.
-fn parse_block_or_stmt(s: &mut ParserContext) -> Result<Box<Stmt>> {
+fn parse_block_or_stmt(s: &mut ParserContext) -> Result<Stmt> {
     if let Some(block) = opt(s, parse_block)? {
-        Ok(Box::new(Stmt {
+        Ok(Stmt {
             span: block.span,
             annotations: Default::default(),
             kind: Box::new(StmtKind::Block(block)),
-        }))
-    } else {
-        Ok(parse(s)?)
-    }
-}
-
-fn into_stmt_list(stmt: Stmt) -> List<Stmt> {
-    if let StmtKind::Block(block) = *stmt.kind {
-        block.stmts
+        })
     } else {
-        Box::new([Box::new(stmt)])
+        Ok(*parse(s)?)
     }
 }
 
@@ -1167,18 +1161,18 @@ pub fn parse_if_stmt(s: &mut ParserContext) -> Result<IfStmt> {
     let condition = expr::expr(s)?;
     recovering_token(s, TokenKind::Close(Delim::Paren));
 
-    let if_block = into_stmt_list(*parse_block_or_stmt(s)?);
+    let if_block = parse_block_or_stmt(s)?;
     let else_block = if opt(s, |s| token(s, TokenKind::Keyword(Keyword::Else)))?.is_some() {
-        Some(into_stmt_list(*parse_block_or_stmt(s)?))
+        Some(parse_block_or_stmt(s)?)
     } else {
         None
     };
 
     Ok(IfStmt {
         span: s.span(lo),
         condition,
-        if_block,
-        else_block,
+        if_body: if_block,
+        else_body: else_block,
     })
 }
 
@@ -1236,14 +1230,14 @@ pub fn parse_for_loop(s: &mut ParserContext) -> Result<ForStmt> {
     let identifier = Identifier::Ident(Box::new(prim::ident(s)?));
     token(s, TokenKind::Keyword(Keyword::In))?;
     let set_declaration = Box::new(for_loop_iterable_expr(s)?);
-    let block = into_stmt_list(*parse_block_or_stmt(s)?);
+    let block = parse_block_or_stmt(s)?;
 
     Ok(ForStmt {
         span: s.span(lo),
         ty,
         identifier,
         set_declaration,
-        block,
+        body: block,
     })
 }
 
@@ -1255,12 +1249,12 @@ pub fn parse_while_loop(s: &mut ParserContext) -> Result<WhileLoop> {
     token(s, TokenKind::Open(Delim::Paren))?;
     let while_condition = expr::expr(s)?;
     recovering_token(s, TokenKind::Close(Delim::Paren));
-    let block = into_stmt_list(*parse_block_or_stmt(s)?);
+    let block = parse_block_or_stmt(s)?;
 
     Ok(WhileLoop {
         span: s.span(lo),
         while_condition,
-        block,
+        body: block,
     })
 }