Lower control flow stmts in QASM3 parser (#2232)

This PR:
 1. Aliases super::ast to semantic.
2. Fixes The bodies of if, for, and while to be `Stmt` instead of
`List<Stmt>`.
 3. Lowers the if, for, while, and switch stmts.
4. Refactors the pattern used to handle lowering of optional items by
introducing the `short_circuit_opt_item!` macro.

Author: orpuente-MS

Diff for: compiler/qsc_qasm3/src/parser/ast.rs

@@ -1369,7 +1369,7 @@ impl Display for WhileLoop {
 pub struct ForStmt {
     pub span: Span,
     pub ty: ScalarType,
-    pub identifier: Identifier,
+    pub ident: Ident,
     pub set_declaration: Box<EnumerableSet>,
     pub body: Stmt,
 }
@@ -1378,7 +1378,7 @@ impl Display for ForStmt {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         writeln_header(f, "ForStmt", self.span)?;
         writeln_field(f, "variable_type", &self.ty)?;
-        writeln_field(f, "variable_name", &self.identifier)?;
+        writeln_field(f, "variable_name", &self.ident)?;
         writeln_field(f, "iterable", &self.set_declaration)?;
         write_field(f, "body", &self.body)
     }

Diff for: compiler/qsc_qasm3/src/parser/mut_visit.rs

@@ -486,7 +486,7 @@ fn walk_extern_stmt(vis: &mut impl MutVisitor, stmt: &mut ExternDecl) {
 fn walk_for_stmt(vis: &mut impl MutVisitor, stmt: &mut ForStmt) {
     vis.visit_span(&mut stmt.span);
     vis.visit_scalar_type(&mut stmt.ty);
-    vis.visit_identifier(&mut stmt.identifier);
+    vis.visit_ident(&mut stmt.ident);
     vis.visit_enumerable_set(&mut stmt.set_declaration);
     vis.visit_stmt(&mut stmt.body);
 }

Diff for: compiler/qsc_qasm3/src/parser/stmt.rs

@@ -119,7 +119,7 @@ pub(super) fn parse(s: &mut ParserContext) -> Result<Stmt> {
         StmtKind::Switch(switch)
     } else if let Some(stmt) = opt(s, parse_if_stmt)? {
         StmtKind::If(stmt)
-    } else if let Some(stmt) = opt(s, parse_for_loop)? {
+    } else if let Some(stmt) = opt(s, parse_for_stmt)? {
         StmtKind::For(stmt)
     } else if let Some(stmt) = opt(s, parse_while_loop)? {
         StmtKind::WhileLoop(stmt)
@@ -1226,19 +1226,19 @@ fn for_loop_iterable_expr(s: &mut ParserContext) -> Result<EnumerableSet> {
 /// Grammar:
 /// `FOR scalarType Identifier IN (setExpression | LBRACKET rangeExpression RBRACKET | expression) body=statementOrScope`.
 /// Reference: <https://openqasm.com/language/classical.html#for-loops>.
-pub fn parse_for_loop(s: &mut ParserContext) -> Result<ForStmt> {
+pub fn parse_for_stmt(s: &mut ParserContext) -> Result<ForStmt> {
     let lo = s.peek().span.lo;
     token(s, TokenKind::Keyword(Keyword::For))?;
     let ty = scalar_type(s)?;
-    let identifier = Identifier::Ident(Box::new(prim::ident(s)?));
+    let ident = prim::ident(s)?;
     token(s, TokenKind::Keyword(Keyword::In))?;
     let set_declaration = Box::new(for_loop_iterable_expr(s)?);
     let block = parse_block_or_stmt(s)?;
 
     Ok(ForStmt {
         span: s.span(lo),
         ty,
-        identifier,
+        ident,
         set_declaration,
         body: block,
     })

Diff for: compiler/qsc_qasm3/src/parser/stmt/tests/for_loops.rs

@@ -5,7 +5,7 @@ use crate::parser::{stmt::parse, tests::check};
 use expect_test::expect;
 
 #[test]
-fn simple_for_loop() {
+fn simple_for_stmt() {
     check(
         parse,
         "
@@ -38,7 +38,7 @@ fn simple_for_loop() {
 }
 
 #[test]
-fn empty_for_loop() {
+fn empty_for_stmt_body() {
     check(
         parse,
         "for int x in {} {}",
@@ -58,7 +58,7 @@ fn empty_for_loop() {
 }
 
 #[test]
-fn simple_for_loop_stmt_body() {
+fn simple_for_stmt_stmt_body() {
     check(
         parse,
         "
@@ -88,7 +88,7 @@ fn simple_for_loop_stmt_body() {
 }
 
 #[test]
-fn for_loop_range() {
+fn for_stmt_iterating_over_range() {
     check(
         parse,
         "
@@ -120,7 +120,7 @@ fn for_loop_range() {
 }
 
 #[test]
-fn for_loop_range_no_step() {
+fn for_stmt_iterating_over_range_no_step() {
     check(
         parse,
         "
@@ -152,7 +152,7 @@ fn for_loop_range_no_step() {
 }
 
 #[test]
-fn for_loop_expr() {
+fn for_stmt_iterating_over_expr() {
     check(
         parse,
         "
@@ -181,7 +181,7 @@ fn for_loop_expr() {
 }
 
 #[test]
-fn for_loop_with_continue_stmt() {
+fn for_stmt_with_continue_stmt() {
     check(
         parse,
         "
@@ -351,3 +351,27 @@ fn nested_single_stmt_for_stmt() {
                                             indices: <empty>"#]],
     );
 }
+
+#[test]
+fn for_stmt_with_indented_identifier_errors() {
+    check(
+        parse,
+        "for int x[2] in {} {}",
+        &expect![[r#"
+            Error(
+                Token(
+                    Keyword(
+                        In,
+                    ),
+                    Open(
+                        Bracket,
+                    ),
+                    Span {
+                        lo: 9,
+                        hi: 10,
+                    },
+                ),
+            )
+        "#]],
+    );
+}

Diff for: compiler/qsc_qasm3/src/semantic/ast.rs

@@ -433,16 +433,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())
     }
 }
 
@@ -1316,33 +1316,31 @@ 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)
     }
 }
 
 #[derive(Clone, Debug)]
 pub struct ForStmt {
     pub span: Span,
-    pub ty: ScalarType,
-    pub identifier: Identifier,
+    pub loop_variable: SymbolId,
     pub set_declaration: Box<EnumerableSet>,
-    pub block: List<Stmt>,
+    pub body: Stmt,
 }
 
 impl Display for ForStmt {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         writeln_header(f, "ForStmt", self.span)?;
-        writeln_field(f, "variable_type", &self.ty)?;
-        writeln_field(f, "variable_name", &self.identifier)?;
+        writeln_field(f, "loop_variable", &self.loop_variable)?;
         writeln_field(f, "iterable", &self.set_declaration)?;
-        write_list_field(f, "block", &self.block)
+        write_field(f, "body", &self.body)
     }
 }
 
@@ -1599,13 +1597,43 @@ impl Display for LiteralKind {
     }
 }
 
-#[derive(Debug, Clone, Copy, PartialEq)]
+#[derive(Debug, Clone, Copy)]
 pub struct Version {
     pub major: u32,
     pub minor: Option<u32>,
     pub span: Span,
 }
 
+impl PartialEq for Version {
+    fn eq(&self, other: &Self) -> bool {
+        // If the minor versions are missing
+        // we assume them to be 0.
+        let self_minor = self.minor.unwrap_or_default();
+        let other_minor = other.minor.unwrap_or_default();
+
+        // Then we check if the major and minor version are equal.
+        self.major == other.major && self_minor == other_minor
+    }
+}
+
+impl PartialOrd for Version {
+    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
+        // If the minor versions are missing
+        // we assume them to be 0.
+        let self_minor = self.minor.unwrap_or_default();
+        let other_minor = other.minor.unwrap_or_default();
+
+        // We compare the major versions.
+        match self.major.partial_cmp(&other.major) {
+            // If they are equal, we disambiguate
+            // using the minor versions.
+            Some(core::cmp::Ordering::Equal) => self_minor.partial_cmp(&other_minor),
+            // Else, we return their ordering.
+            ord => ord,
+        }
+    }
+}
+
 impl fmt::Display for Version {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self.minor {

Diff for: compiler/qsc_qasm3/src/semantic/error.rs

@@ -132,6 +132,9 @@ pub enum SemanticErrorKind {
     #[error("{0} are not supported.")]
     #[diagnostic(code("Qsc.Qasm3.Compile.NotSupported"))]
     NotSupported(String, #[label] Span),
+    #[error("{0} were introduced in version {1}")]
+    #[diagnostic(code("Qsc.Qasm3.Compile.NotSupportedInThisVersion"))]
+    NotSupportedInThisVersion(String, String, #[label] Span),
     #[error("The operator {0} is not valid with lhs {1} and rhs {2}.")]
     #[diagnostic(code("Qsc.Qasm3.Compile.OperatorNotSupportedForTypes"))]
     OperatorNotSupportedForTypes(String, String, String, #[label] Span),
@@ -286,6 +289,9 @@ impl SemanticErrorKind {
             }
             Self::NegativeControlCount(span) => Self::NegativeControlCount(span + offset),
             Self::NotSupported(name, span) => Self::NotSupported(name, span + offset),
+            Self::NotSupportedInThisVersion(name, version, span) => {
+                Self::NotSupportedInThisVersion(name, version, span + offset)
+            }
             Self::OperatorNotSupportedForTypes(op, lhs, rhs, span) => {
                 Self::OperatorNotSupportedForTypes(op, lhs, rhs, span + offset)
             }