Add array and measurement declaration statements (#2180)

orpuente-MS · web-flow · commit dced819c63e8 · 2025-02-13T13:19:52.000-08:00
diff --git a/compiler/qsc_qasm3/src/ast.rs b/compiler/qsc_qasm3/src/ast.rs
@@ -300,14 +300,14 @@ impl Display for UnaryOp {
 
 #[derive(Clone, Debug)]
 pub enum GateOperand {
-    Ident(Box<Identifier>),
+    IndexedIdent(Box<IndexedIdent>),
     HardwareQubit(Box<HardwareQubit>),
 }
 
 impl Display for GateOperand {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         match self {
-            GateOperand::Ident(ident) => write!(f, "GateOperand {ident}"),
+            GateOperand::IndexedIdent(ident) => write!(f, "GateOperand {ident}"),
             GateOperand::HardwareQubit(qubit) => write!(f, "GateOperand {qubit}"),
         }
     }
@@ -1333,7 +1333,7 @@ impl Display for ClassicalDeclarationStmt {
 #[derive(Clone, Debug)]
 pub enum ValueExpression {
     Expr(ExprStmt),
-    Measurement(QuantumMeasurement),
+    Measurement(MeasureExpr),
 }
 
 impl Display for ValueExpression {
@@ -1876,7 +1876,7 @@ impl Display for Lit {
 
 #[derive(Clone, Debug)]
 pub enum LiteralKind {
-    Array(List<ExprStmt>),
+    Array(List<Expr>),
     Bitstring(BigInt, usize),
     Bool(bool),
     Duration { value: f64, unit: TimeUnit },
diff --git a/compiler/qsc_qasm3/src/parser/expr.rs b/compiler/qsc_qasm3/src/parser/expr.rs
@@ -16,9 +16,10 @@ use qsc_data_structures::span::Span;
 
 use crate::{
     ast::{
-        self, AssignExpr, AssignOpExpr, BinOp, BinaryOpExpr, Cast, DiscreteSet, Expr, ExprKind,
-        ExprStmt, FunctionCall, IndexElement, IndexExpr, IndexSetItem, Lit, LiteralKind,
-        RangeDefinition, TypeDef, UnaryOp, ValueExpression, Version,
+        self, list_from_iter, AssignExpr, AssignOpExpr, BinOp, BinaryOpExpr, Cast, DiscreteSet,
+        Expr, ExprKind, ExprStmt, FunctionCall, GateOperand, HardwareQubit, Ident, IndexElement,
+        IndexExpr, IndexSetItem, IndexedIdent, Lit, LiteralKind, MeasureExpr, RangeDefinition,
+        TypeDef, UnaryOp, ValueExpression, Version,
     },
     keyword::Keyword,
     lex::{
@@ -36,7 +37,7 @@ use crate::parser::Result;
 
 use super::{
     error::{Error, ErrorKind},
-    prim::{ident, opt, seq, FinalSep},
+    prim::{ident, many, opt, recovering_token, seq, FinalSep},
     stmt::scalar_or_array_type,
 };
 
@@ -458,7 +459,7 @@ fn cast_op(s: &mut ParserContext, r#type: TypeDef) -> Result<ExprKind> {
 fn index_expr(s: &mut ParserContext, lhs: Expr) -> Result<ExprKind> {
     let lo = s.span(0).hi - 1;
     let index = index_element(s)?;
-    token(s, TokenKind::Close(Delim::Bracket))?;
+    recovering_token(s, TokenKind::Close(Delim::Bracket));
     Ok(ExprKind::IndexExpr(IndexExpr {
         span: s.span(lo),
         collection: lhs,
@@ -662,17 +663,96 @@ pub(super) fn designator(s: &mut ParserContext) -> Result<ExprStmt> {
     })
 }
 
+/// A literal array is a list of literal array elements.
+fn lit_array(s: &mut ParserContext) -> Result<Expr> {
+    let lo = s.peek().span.lo;
+    token(s, TokenKind::Open(Delim::Brace))?;
+    let elements = seq(s, lit_array_element).map(|pair| pair.0)?;
+    recovering_token(s, TokenKind::Close(Delim::Brace));
+    Ok(Expr {
+        span: s.span(lo),
+        kind: Box::new(ExprKind::Lit(Lit {
+            span: s.span(lo),
+            kind: LiteralKind::Array(list_from_iter(elements)),
+        })),
+    })
+}
+
+/// A literal array element can be an expression, or a literal array element.
+fn lit_array_element(s: &mut ParserContext) -> Result<Expr> {
+    if let Some(elt) = opt(s, expr)? {
+        return Ok(elt);
+    }
+    lit_array(s)
+}
+
 pub(super) fn value_expr(s: &mut ParserContext) -> Result<Box<ValueExpression>> {
     let lo = s.peek().span.lo;
-    let expr = expr_stmt(s)?;
+    if let Some(measurement) = opt(s, measure_expr)? {
+        return Ok(Box::new(ValueExpression::Measurement(measurement)));
+    }
+
+    let expr = if let Some(expr) = opt(s, expr_stmt)? {
+        expr
+    } else {
+        lit_array(s)?
+    };
+
     let stmt = ExprStmt {
         span: s.span(lo),
         expr,
     };
-    // todo: measurement
+
     Ok(Box::new(ValueExpression::Expr(stmt)))
 }
 
-pub(crate) fn expr_list(s: &mut ParserContext<'_>) -> Result<Vec<Expr>> {
+pub(crate) fn expr_list(s: &mut ParserContext) -> Result<Vec<Expr>> {
     seq(s, expr).map(|pair| pair.0)
 }
+
+fn measure_expr(s: &mut ParserContext) -> Result<MeasureExpr> {
+    let lo = s.peek().span.lo;
+    token(s, TokenKind::Measure)?;
+
+    Ok(MeasureExpr {
+        span: s.span(lo),
+        operand: gate_operand(s)?,
+    })
+}
+
+fn gate_operand(s: &mut ParserContext) -> Result<GateOperand> {
+    if let Some(indexed_ident) = opt(s, indexed_identifier)? {
+        return Ok(GateOperand::IndexedIdent(Box::new(indexed_ident)));
+    }
+    Ok(GateOperand::HardwareQubit(Box::new(hardware_qubit(s)?)))
+}
+
+fn hardware_qubit(s: &mut ParserContext) -> Result<HardwareQubit> {
+    let lo = s.peek().span.lo;
+    let hardware_qubit = s.read();
+    token(s, TokenKind::HardwareQubit)?;
+
+    Ok(HardwareQubit {
+        span: s.span(lo),
+        name: hardware_qubit[1..].into(),
+    })
+}
+
+fn indexed_identifier(s: &mut ParserContext) -> Result<IndexedIdent> {
+    let lo = s.peek().span.lo;
+    let name: Ident = ident(s)?;
+    let indices = list_from_iter(many(s, index_operand)?);
+
+    Ok(IndexedIdent {
+        span: s.span(lo),
+        name,
+        indices,
+    })
+}
+
+fn index_operand(s: &mut ParserContext) -> Result<IndexElement> {
+    token(s, TokenKind::Open(Delim::Bracket))?;
+    let index = index_element(s)?;
+    recovering_token(s, TokenKind::Close(Delim::Bracket));
+    Ok(index)
+}
diff --git a/compiler/qsc_qasm3/src/parser/expr/tests.rs b/compiler/qsc_qasm3/src/parser/expr/tests.rs
@@ -1141,6 +1141,18 @@ fn set_expr() {
     );
 }
 
+#[test]
+fn lit_array() {
+    check(
+        super::lit_array,
+        "{{2, {5}}, 1 + z}",
+        &expect![[r#"
+            Expr [0-17]: Lit: Array:
+                Expr { span: Span { lo: 1, hi: 9 }, kind: Lit(Lit { span: Span { lo: 1, hi: 9 }, kind: Array([Expr { span: Span { lo: 2, hi: 3 }, kind: Lit(Lit { span: Span { lo: 2, hi: 3 }, kind: Int(2) }) }, Expr { span: Span { lo: 5, hi: 8 }, kind: Lit(Lit { span: Span { lo: 5, hi: 8 }, kind: Array([Expr { span: Span { lo: 6, hi: 7 }, kind: Lit(Lit { span: Span { lo: 6, hi: 7 }, kind: Int(5) }) }]) }) }]) }) }
+                Expr { span: Span { lo: 11, hi: 16 }, kind: BinaryOp(BinaryOpExpr { op: Add, lhs: Expr { span: Span { lo: 11, hi: 12 }, kind: Lit(Lit { span: Span { lo: 11, hi: 12 }, kind: Int(1) }) }, rhs: Expr { span: Span { lo: 15, hi: 16 }, kind: Ident(Ident { span: Span { lo: 15, hi: 16 }, name: "z" }) } }) }"#]],
+    );
+}
+
 #[test]
 fn assignment_and_unop() {
     check(
@@ -1168,3 +1180,49 @@ fn assignment_unop_and() {
                 Expr [15-16]: Ident [15-16] "b""#]],
     );
 }
+
+#[test]
+fn hardware_qubit() {
+    check(
+        super::hardware_qubit,
+        "$12",
+        &expect!["HardwareQubit [0-3]: 12"],
+    );
+}
+
+#[test]
+fn indexed_identifier() {
+    check(
+        super::indexed_identifier,
+        "arr[1][2]",
+        &expect![[r#"
+        IndexedIdent [0-9]: Ident [0-3] "arr"[
+        IndexElement:
+            IndexSetItem Expr [4-5]: Lit: Int(1)
+        IndexElement:
+            IndexSetItem Expr [7-8]: Lit: Int(2)]"#]],
+    );
+}
+
+#[test]
+fn measure_hardware_qubit() {
+    check(
+        super::measure_expr,
+        "measure $12",
+        &expect!["MeasureExpr [0-7]: GateOperand HardwareQubit [8-11]: 12"],
+    );
+}
+
+#[test]
+fn measure_indexed_identifier() {
+    check(
+        super::measure_expr,
+        "measure qubits[1][2]",
+        &expect![[r#"
+        MeasureExpr [0-7]: GateOperand IndexedIdent [8-20]: Ident [8-14] "qubits"[
+        IndexElement:
+            IndexSetItem Expr [15-16]: Lit: Int(1)
+        IndexElement:
+            IndexSetItem Expr [18-19]: Lit: Int(2)]"#]],
+    );
+}
diff --git a/compiler/qsc_qasm3/src/parser/stmt/tests/classical_decl.rs b/compiler/qsc_qasm3/src/parser/stmt/tests/classical_decl.rs
@@ -668,3 +668,72 @@ fn stretch_decl() {
                 StmtKind: ClassicalDeclarationStmt [0-10]: ClassicalType [0-7]: Stretch, Ident [8-9] "s""#]],
     );
 }
+
+#[test]
+fn empty_array_decl() {
+    check(
+        parse,
+        "array[int, 0] arr = {};",
+        &expect![[r#"
+            Stmt [0-23]
+                StmtKind: ClassicalDeclarationStmt [0-23]: ArrayType [0-13]: ArrayBaseTypeKind IntType [6-9]
+                Expr [11-12]: Lit: Int(0), Ident [14-17] "arr", ValueExpression ExprStmt [20-22]: Expr [20-22]: Lit: Array:"#]],
+    );
+}
+
+#[test]
+fn simple_array_decl() {
+    check(
+        parse,
+        "array[int[32], 3] arr = {1, 2, 3};",
+        &expect![[r#"
+        Stmt [0-34]
+            StmtKind: ClassicalDeclarationStmt [0-34]: ArrayType [0-17]: ArrayBaseTypeKind IntType[ExprStmt [9-13]: Expr [10-12]: Lit: Int(32)]: [6-13]
+            Expr [15-16]: Lit: Int(3), Ident [18-21] "arr", ValueExpression ExprStmt [24-33]: Expr [24-33]: Lit: Array:
+                Expr { span: Span { lo: 25, hi: 26 }, kind: Lit(Lit { span: Span { lo: 25, hi: 26 }, kind: Int(1) }) }
+                Expr { span: Span { lo: 28, hi: 29 }, kind: Lit(Lit { span: Span { lo: 28, hi: 29 }, kind: Int(2) }) }
+                Expr { span: Span { lo: 31, hi: 32 }, kind: Lit(Lit { span: Span { lo: 31, hi: 32 }, kind: Int(3) }) }"#]],
+    );
+}
+
+#[test]
+fn nested_array_decl() {
+    check(
+        parse,
+        "array[int[32], 3, 2] arr = {{1, 2}, {3, 4}, {5, 6}};",
+        &expect![[r#"
+            Stmt [0-52]
+                StmtKind: ClassicalDeclarationStmt [0-52]: ArrayType [0-20]: ArrayBaseTypeKind IntType[ExprStmt [9-13]: Expr [10-12]: Lit: Int(32)]: [6-13]
+                Expr [15-16]: Lit: Int(3)
+                Expr [18-19]: Lit: Int(2), Ident [21-24] "arr", ValueExpression ExprStmt [27-51]: Expr [27-51]: Lit: Array:
+                    Expr { span: Span { lo: 28, hi: 34 }, kind: Lit(Lit { span: Span { lo: 28, hi: 34 }, kind: Array([Expr { span: Span { lo: 29, hi: 30 }, kind: Lit(Lit { span: Span { lo: 29, hi: 30 }, kind: Int(1) }) }, Expr { span: Span { lo: 32, hi: 33 }, kind: Lit(Lit { span: Span { lo: 32, hi: 33 }, kind: Int(2) }) }]) }) }
+                    Expr { span: Span { lo: 36, hi: 42 }, kind: Lit(Lit { span: Span { lo: 36, hi: 42 }, kind: Array([Expr { span: Span { lo: 37, hi: 38 }, kind: Lit(Lit { span: Span { lo: 37, hi: 38 }, kind: Int(3) }) }, Expr { span: Span { lo: 40, hi: 41 }, kind: Lit(Lit { span: Span { lo: 40, hi: 41 }, kind: Int(4) }) }]) }) }
+                    Expr { span: Span { lo: 44, hi: 50 }, kind: Lit(Lit { span: Span { lo: 44, hi: 50 }, kind: Array([Expr { span: Span { lo: 45, hi: 46 }, kind: Lit(Lit { span: Span { lo: 45, hi: 46 }, kind: Int(5) }) }, Expr { span: Span { lo: 48, hi: 49 }, kind: Lit(Lit { span: Span { lo: 48, hi: 49 }, kind: Int(6) }) }]) }) }"#]],
+    );
+}
+
+#[test]
+fn measure_hardware_qubit_decl() {
+    check(
+        parse,
+        "bit res = measure $12;",
+        &expect![[r#"
+            Stmt [0-22]
+                StmtKind: ClassicalDeclarationStmt [0-22]: ClassicalType [0-3]: BitType, Ident [4-7] "res", ValueExpression MeasureExpr [10-17]: GateOperand HardwareQubit [18-21]: 12"#]],
+    );
+}
+
+#[test]
+fn measure_register_decl() {
+    check(
+        parse,
+        "bit res = measure qubits[2][3];",
+        &expect![[r#"
+            Stmt [0-31]
+                StmtKind: ClassicalDeclarationStmt [0-31]: ClassicalType [0-3]: BitType, Ident [4-7] "res", ValueExpression MeasureExpr [10-17]: GateOperand IndexedIdent [18-30]: Ident [18-24] "qubits"[
+                IndexElement:
+                    IndexSetItem Expr [25-26]: Lit: Int(2)
+                IndexElement:
+                    IndexSetItem Expr [28-29]: Lit: Int(3)]"#]],
+    );
+}
