Add gate calls and the AST items it depends on to the new QASM3 compiler

compiler/qsc_qasm3/src/parser/ast.rs

@@ -147,6 +147,7 @@ impl WithSpan for Path {
 #[derive(Clone, Debug)]
 pub struct MeasureExpr {
     pub span: Span,
+    pub measure_token_span: Span,
     pub operand: GateOperand,
 }
 
@@ -248,29 +249,51 @@ impl Display for UnaryOp {
 }
 
 #[derive(Clone, Debug, Default)]
-pub enum GateOperand {
+pub struct GateOperand {
+    pub span: Span,
+    pub kind: GateOperandKind,
+}
+
+impl WithSpan for GateOperand {
+    fn with_span(self, span: Span) -> Self {
+        Self {
+            span,
+            kind: self.kind.with_span(span),
+        }
+    }
+}
+
+impl Display for GateOperand {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        writeln_header(f, "GateOperand", self.span)?;
+        write_field(f, "kind", &self.kind)
+    }
+}
+
+#[derive(Clone, Debug, Default)]
+pub enum GateOperandKind {
     IndexedIdent(Box<IndexedIdent>),
     HardwareQubit(Box<HardwareQubit>),
     #[default]
     Err,
 }
 
-impl Display for GateOperand {
+impl Display for GateOperandKind {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         match self {
-            GateOperand::IndexedIdent(ident) => write!(f, "{ident}"),
-            GateOperand::HardwareQubit(qubit) => write!(f, "{qubit}"),
-            GateOperand::Err => write!(f, "Error"),
+            Self::IndexedIdent(ident) => write!(f, "{ident}"),
+            Self::HardwareQubit(qubit) => write!(f, "{qubit}"),
+            Self::Err => write!(f, "Error"),
         }
     }
 }
 
-impl WithSpan for GateOperand {
+impl WithSpan for GateOperandKind {
     fn with_span(self, span: Span) -> Self {
         match self {
-            GateOperand::IndexedIdent(ident) => GateOperand::IndexedIdent(ident.with_span(span)),
-            GateOperand::HardwareQubit(qubit) => GateOperand::HardwareQubit(qubit.with_span(span)),
-            GateOperand::Err => GateOperand::Err,
+            Self::IndexedIdent(ident) => Self::IndexedIdent(ident.with_span(span)),
+            Self::HardwareQubit(qubit) => Self::HardwareQubit(qubit.with_span(span)),
+            Self::Err => Self::Err,
         }
     }
 }
@@ -335,7 +358,7 @@ pub enum StmtKind {
     GPhase(GPhase),
     Include(IncludeStmt),
     IODeclaration(IODeclaration),
-    Measure(MeasureStmt),
+    Measure(MeasureArrowStmt),
     Pragma(Pragma),
     QuantumGateDefinition(QuantumGateDefinition),
     QuantumDecl(QubitDeclaration),
@@ -445,12 +468,14 @@ impl Display for BarrierStmt {
 #[derive(Clone, Debug)]
 pub struct ResetStmt {
     pub span: Span,
+    pub reset_token_span: Span,
     pub operand: Box<GateOperand>,
 }
 
 impl Display for ResetStmt {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         writeln_header(f, "ResetStmt", self.span)?;
+        writeln_field(f, "reset_token_span", &self.reset_token_span)?;
         write_field(f, "operand", &self.operand)
     }
 }
@@ -991,13 +1016,15 @@ impl Display for IncludeStmt {
 #[derive(Clone, Debug)]
 pub struct QubitDeclaration {
     pub span: Span,
+    pub ty_span: Span,
     pub qubit: Ident,
     pub size: Option<Expr>,
 }
 
 impl Display for QubitDeclaration {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         writeln_header(f, "QubitDeclaration", self.span)?;
+        writeln_field(f, "ty_span", &self.ty_span)?;
         writeln_field(f, "ident", &self.qubit)?;
         write_opt_field(f, "size", self.size.as_ref())
     }
@@ -1110,15 +1137,15 @@ impl Display for BoxStmt {
 }
 
 #[derive(Clone, Debug)]
-pub struct MeasureStmt {
+pub struct MeasureArrowStmt {
     pub span: Span,
     pub measurement: MeasureExpr,
     pub target: Option<Box<IndexedIdent>>,
 }
 
-impl Display for MeasureStmt {
+impl Display for MeasureArrowStmt {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
-        writeln_header(f, "MeasureStmt", self.span)?;
+        writeln_header(f, "MeasureArrowStmt", self.span)?;
         writeln_field(f, "measurement", &self.measurement)?;
         write_opt_field(f, "target", self.target.as_ref())
     }
@@ -1129,7 +1156,7 @@ pub struct ClassicalDeclarationStmt {
     pub span: Span,
     pub ty: Box<TypeDef>,
     pub identifier: Ident,
-    pub init_expr: Option<Box<ValueExpression>>,
+    pub init_expr: Option<Box<ValueExpr>>,
 }
 
 impl Display for ClassicalDeclarationStmt {
@@ -1142,16 +1169,16 @@ impl Display for ClassicalDeclarationStmt {
 }
 
 #[derive(Clone, Debug)]
-pub enum ValueExpression {
+pub enum ValueExpr {
     Expr(Expr),
     Measurement(MeasureExpr),
 }
 
-impl Display for ValueExpression {
+impl Display for ValueExpr {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         match self {
-            ValueExpression::Expr(expr) => write!(f, "{expr}"),
-            ValueExpression::Measurement(measure) => write!(f, "{measure}"),
+            Self::Expr(expr) => write!(f, "{expr}"),
+            Self::Measurement(measure) => write!(f, "{measure}"),
         }
     }
 }
@@ -1178,7 +1205,7 @@ pub struct ConstantDeclStmt {
     pub span: Span,
     pub ty: TypeDef,
     pub identifier: Box<Ident>,
-    pub init_expr: Expr,
+    pub init_expr: ValueExpr,
 }
 
 impl Display for ConstantDeclStmt {
@@ -1339,7 +1366,7 @@ impl Display for DefStmt {
 #[derive(Clone, Debug)]
 pub struct ReturnStmt {
     pub span: Span,
-    pub expr: Option<Box<ValueExpression>>,
+    pub expr: Option<Box<ValueExpr>>,
 }
 
 impl Display for ReturnStmt {
@@ -1470,7 +1497,7 @@ impl Display for ExprKind {
 pub struct AssignStmt {
     pub span: Span,
     pub lhs: IndexedIdent,
-    pub rhs: Expr,
+    pub rhs: ValueExpr,
 }
 
 impl Display for AssignStmt {
@@ -1486,7 +1513,7 @@ pub struct AssignOpStmt {
     pub span: Span,
     pub op: BinOp,
     pub lhs: IndexedIdent,
-    pub rhs: Expr,
+    pub rhs: ValueExpr,
 }
 
 impl Display for AssignOpStmt {

compiler/qsc_qasm3/src/parser/ast/display_utils.rs

@@ -129,7 +129,7 @@ pub(crate) fn writeln_opt_field<T: Display>(
     writeln!(f)
 }
 
-/// Writes an field of a structure to the given buffer
+/// Writes a field of a structure to the given buffer
 /// or stream with an additional indententation level.
 /// The field must be an iterable.
 pub(crate) fn write_list_field<'write, 'itemref, 'item, T, I>(
@@ -148,7 +148,7 @@ where
     write_list(&mut indent, vals)
 }
 
-/// Writes an field of a structure to the given buffer
+/// Writes a field of a structure to the given buffer
 /// or stream with an additional indententation level.
 /// The field must be an iterable.
 /// Inserts a newline afterwards.

compiler/qsc_qasm3/src/parser/expr.rs

@@ -24,9 +24,9 @@ use crate::parser::Result;
 use super::{
     ast::{
         list_from_iter, BinOp, BinaryOpExpr, Cast, DiscreteSet, Expr, ExprKind, FunctionCall,
-        GateOperand, HardwareQubit, Ident, IndexElement, IndexExpr, IndexSet, IndexSetItem,
-        IndexedIdent, List, Lit, LiteralKind, MeasureExpr, RangeDefinition, TimeUnit, TypeDef,
-        UnaryOp, UnaryOpExpr, ValueExpression, Version,
+        GateOperand, GateOperandKind, HardwareQubit, Ident, IndexElement, IndexExpr, IndexSet,
+        IndexSetItem, IndexedIdent, List, Lit, LiteralKind, MeasureExpr, RangeDefinition, TimeUnit,
+        TypeDef, UnaryOp, UnaryOpExpr, ValueExpr, Version,
     },
     completion::WordKinds,
     error::{Error, ErrorKind},
@@ -708,9 +708,11 @@ fn lit_array_element(s: &mut ParserContext) -> Result<Expr> {
     lit_array(s)
 }
 
-pub(super) fn value_expr(s: &mut ParserContext) -> Result<Box<ValueExpression>> {
+/// These are expressions allowed in classical declarations.
+/// Grammar: `arrayLiteral | expression | measureExpression`.
+pub(super) fn declaration_expr(s: &mut ParserContext) -> Result<ValueExpr> {
     if let Some(measurement) = opt(s, measure_expr)? {
-        return Ok(Box::new(ValueExpression::Measurement(measurement)));
+        return Ok(ValueExpr::Measurement(measurement));
     }
 
     let expr = if let Some(expr) = opt(s, expr)? {
@@ -719,7 +721,17 @@ pub(super) fn value_expr(s: &mut ParserContext) -> Result<Box<ValueExpression>>
         lit_array(s)?
     };
 
-    Ok(Box::new(ValueExpression::Expr(expr)))
+    Ok(ValueExpr::Expr(expr))
+}
+
+/// These are expressions allowed in `Assign`, `AssignOp`, and return stmts.
+/// Grammar: `expression | measureExpression`.
+pub(super) fn expr_or_measurement(s: &mut ParserContext) -> Result<ValueExpr> {
+    if let Some(measurement) = opt(s, measure_expr)? {
+        return Ok(ValueExpr::Measurement(measurement));
+    }
+
+    Ok(ValueExpr::Expr(expr(s)?))
 }
 
 pub(crate) fn expr_list(s: &mut ParserContext) -> Result<Vec<Expr>> {
@@ -729,18 +741,28 @@ pub(crate) fn expr_list(s: &mut ParserContext) -> Result<Vec<Expr>> {
 pub(crate) fn measure_expr(s: &mut ParserContext) -> Result<MeasureExpr> {
     let lo = s.peek().span.lo;
     token(s, TokenKind::Measure)?;
+    let measure_token_span = s.span(lo);
+    let operand = gate_operand(s)?;
 
     Ok(MeasureExpr {
         span: s.span(lo),
-        operand: gate_operand(s)?,
+        measure_token_span,
+        operand,
     })
 }
 
 pub(crate) 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)?)))
+    let lo = s.peek().span.lo;
+    let kind = if let Some(indexed_ident) = opt(s, indexed_identifier)? {
+        GateOperandKind::IndexedIdent(Box::new(indexed_ident))
+    } else {
+        GateOperandKind::HardwareQubit(Box::new(hardware_qubit(s)?))
+    };
+
+    Ok(GateOperand {
+        span: s.span(lo),
+        kind,
+    })
 }
 
 fn hardware_qubit(s: &mut ParserContext) -> Result<HardwareQubit> {

compiler/qsc_qasm3/src/parser/expr/tests.rs

@@ -1146,8 +1146,9 @@ fn measure_hardware_qubit() {
         super::measure_expr,
         "measure $12",
         &expect![[r#"
-            MeasureExpr [0-7]:
-                operand: HardwareQubit [8-11]: 12"#]],
+            MeasureExpr [0-11]:
+                operand: GateOperand [8-11]:
+                    kind: HardwareQubit [8-11]: 12"#]],
     );
 }
 
@@ -1157,17 +1158,18 @@ fn measure_indexed_identifier() {
         super::measure_expr,
         "measure qubits[1][2]",
         &expect![[r#"
-            MeasureExpr [0-7]:
-                operand: IndexedIdent [8-20]:
-                    name: Ident [8-14] "qubits"
-                    index_span: [14-20]
-                    indices:
-                        IndexSet [15-16]:
-                            values:
-                                Expr [15-16]: Lit: Int(1)
-                        IndexSet [18-19]:
-                            values:
-                                Expr [18-19]: Lit: Int(2)"#]],
+            MeasureExpr [0-20]:
+                operand: GateOperand [8-20]:
+                    kind: IndexedIdent [8-20]:
+                        name: Ident [8-14] "qubits"
+                        index_span: [14-20]
+                        indices:
+                            IndexSet [15-16]:
+                                values:
+                                    Expr [15-16]: Lit: Int(1)
+                            IndexSet [18-19]:
+                                values:
+                                    Expr [18-19]: Lit: Int(2)"#]],
     );
 }