Add durationof support

Author: idavis

source/compiler/qsc_qasm/src/compiler.rs

@@ -925,6 +925,11 @@ impl QasmCompiler {
         )
     }
 
+    fn compile_durationof_call_expr(&mut self, expr: &semast::DurationofCallExpr) -> qsast::Expr {
+        self.push_unsupported_error_message("durationof call", expr.span);
+        err_expr(expr.span)
+    }
+
     fn compile_gate_call_stmt(&mut self, stmt: &semast::GateCall) -> Option<qsast::Stmt> {
         if let Some(duration) = &stmt.duration {
             self.push_unsupported_error_message("gate call duration", duration.span);
@@ -1397,6 +1402,9 @@ impl QasmCompiler {
             semast::ExprKind::Paren(pexpr) => self.compile_paren_expr(pexpr, expr.span),
             semast::ExprKind::Measure(mexpr) => self.compile_measure_expr(mexpr, &expr.ty),
             semast::ExprKind::SizeofCall(sizeof_call) => self.compile_sizeof_call_expr(sizeof_call),
+            semast::ExprKind::DurationofCall(duration_call) => {
+                self.compile_durationof_call_expr(duration_call)
+            }
         }
     }
 

source/compiler/qsc_qasm/src/parser/ast.rs

@@ -581,6 +581,21 @@ impl Display for Block {
     }
 }
 
+#[derive(Clone, Debug)]
+pub struct DurationofCall {
+    pub span: Span,
+    pub name_span: Span,
+    pub scope: Block,
+}
+
+impl Display for DurationofCall {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        writeln_header(f, "DurationofCall", self.span)?;
+        writeln_field(f, "name_span", &self.name_span)?;
+        write_field(f, "scope", &self.scope)
+    }
+}
+
 #[derive(Clone, Debug)]
 pub enum IdentOrIndexedIdent {
     Ident(Ident),
@@ -1650,6 +1665,7 @@ pub enum ExprKind {
     Cast(Cast),
     IndexExpr(IndexExpr),
     Paren(Expr),
+    DurationOf(DurationofCall),
 }
 
 impl Display for ExprKind {
@@ -1664,6 +1680,7 @@ impl Display for ExprKind {
             ExprKind::Cast(expr) => write!(f, "{expr}"),
             ExprKind::IndexExpr(expr) => write!(f, "{expr}"),
             ExprKind::Paren(expr) => write!(f, "Paren {expr}"),
+            ExprKind::DurationOf(duration) => write!(f, "{duration}"),
         }
     }
 }

source/compiler/qsc_qasm/src/parser/completion/tests.rs

@@ -30,7 +30,7 @@ fn begin_document() {
         "|OPENQASM 3;",
         &expect![[r#"
             WordKinds(
-                PathExpr | Annotation | Barrier | Box | Break | Cal | Const | Continue | CReg | Ctrl | Def | DefCal | DefCalGrammar | Delay | End | Extern | False | For | Gate | If | Include | Input | Inv | Let | Measure | NegCtrl | OpenQASM | Output | Pow | Pragma | QReg | Qubit | Reset | True | Return | Switch | While,
+                PathExpr | Annotation | Durationof | Barrier | Box | Break | Cal | Const | Continue | CReg | Ctrl | Def | DefCal | DefCalGrammar | Delay | End | Extern | False | For | Gate | If | Include | Input | Inv | Let | Measure | NegCtrl | OpenQASM | Output | Pow | Pragma | QReg | Qubit | Reset | True | Return | Switch | While,
             )
         "#]],
     );
@@ -42,7 +42,7 @@ fn end_of_version() {
         "OPENQASM 3;|",
         &expect![[r#"
             WordKinds(
-                PathExpr | Annotation | Barrier | Box | Break | Cal | Const | Continue | CReg | Ctrl | Def | DefCal | DefCalGrammar | Delay | End | Extern | False | For | Gate | If | Include | Input | Inv | Let | Measure | NegCtrl | Output | Pow | Pragma | QReg | Qubit | Reset | True | Return | Switch | While,
+                PathExpr | Annotation | Durationof | Barrier | Box | Break | Cal | Const | Continue | CReg | Ctrl | Def | DefCal | DefCalGrammar | Delay | End | Extern | False | For | Gate | If | Include | Input | Inv | Let | Measure | NegCtrl | Output | Pow | Pragma | QReg | Qubit | Reset | True | Return | Switch | While,
             )
         "#]],
     );

source/compiler/qsc_qasm/src/parser/completion/word_kinds.rs

@@ -58,6 +58,8 @@ bitflags! {
         // End hardcoded identifiers.
         //
 
+        const Durationof = 1 << 3; // `durationof` call, e.g. `durationof (scope)`
+
         //
         // Begin keywords.
         //
@@ -107,7 +109,7 @@ bitflags! {
     }
 }
 
-const KEYWORDS_START: u8 = 3;
+const KEYWORDS_START: u8 = 4;
 const fn keyword_bit(k: Keyword) -> u128 {
     1 << (k as u8 + KEYWORDS_START)
 }

source/compiler/qsc_qasm/src/parser/expr.rs

@@ -17,6 +17,7 @@ use crate::{
         ClosedBinOp, Delim, Radix, Token, TokenKind,
         cooked::{ComparisonOp, Literal, TimingLiteralKind},
     },
+    parser::{ast::DurationofCall, stmt::parse_block},
 };
 
 use crate::parser::Result;
@@ -133,6 +134,8 @@ fn expr_base(s: &mut ParserContext) -> Result<Expr> {
         })
     } else if token(s, TokenKind::Open(Delim::Paren)).is_ok() {
         paren_expr(s, lo)
+    } else if let Some(expr) = opt(s, duration_of)? {
+        Ok(expr)
     } else {
         match opt(s, scalar_or_array_type) {
             Err(err) => Err(err),
@@ -819,3 +822,24 @@ pub fn alias_expr(s: &mut ParserContext) -> Result<List<Expr>> {
     }
     Ok(list_from_iter(exprs))
 }
+
+/// Grammar: `DURATIONOF LPAREN scope RPAREN`
+fn duration_of(s: &mut ParserContext) -> Result<Expr> {
+    let lo = s.peek().span.lo;
+    s.expect(WordKinds::Durationof);
+    token(s, TokenKind::DurationOf)?;
+    let name_span = s.span(lo);
+    token(s, TokenKind::Open(Delim::Paren))?;
+    let scope = parse_block(s)?;
+    recovering_token(s, TokenKind::Close(Delim::Paren));
+    let duration = DurationofCall {
+        span: s.span(lo),
+        name_span,
+        scope,
+    };
+    let expr = Expr {
+        span: s.span(lo),
+        kind: Box::new(ExprKind::DurationOf(duration)),
+    };
+    Ok(expr)
+}

source/compiler/qsc_qasm/src/parser/expr/tests.rs

@@ -1190,3 +1190,24 @@ fn addition_of_casts() {
                     arg: Expr [13-14]: Lit: Int(1)"#]],
     );
 }
+
+#[test]
+fn duration_of() {
+    check_expr(
+        "durationof({x $0;})",
+        &expect![[r#"
+            Expr [0-19]: DurationofCall [0-19]:
+                name_span: [0-10]
+                scope: Block [11-18]:
+                    Stmt [12-17]:
+                        annotations: <empty>
+                        kind: GateCall [12-17]:
+                            modifiers: <empty>
+                            name: Ident [12-13] "x"
+                            args: <empty>
+                            duration: <none>
+                            qubits:
+                                GateOperand [14-16]:
+                                    kind: HardwareQubit [14-16]: 0"#]],
+    );
+}

source/compiler/qsc_qasm/src/parser/mut_visit.rs

@@ -3,7 +3,7 @@
 
 use qsc_data_structures::span::Span;
 
-use crate::parser::ast::{DefParameter, DefParameterType, QubitType};
+use crate::parser::ast::{DefParameter, DefParameterType, DurationofCall, QubitType};
 
 use super::ast::{
     AccessControl, AliasDeclStmt, Annotation, ArrayBaseTypeKind, ArrayReferenceType, ArrayType,
@@ -187,6 +187,10 @@ pub trait MutVisitor: Sized {
         walk_cast_expr(self, expr);
     }
 
+    fn visit_duration_of_expr(&mut self, expr: &mut DurationofCall) {
+        walk_duration_of_expr(self, expr);
+    }
+
     fn visit_index_expr(&mut self, expr: &mut IndexExpr) {
         walk_index_expr(self, expr);
     }
@@ -607,6 +611,7 @@ pub fn walk_expr(vis: &mut impl MutVisitor, expr: &mut Expr) {
         super::ast::ExprKind::Cast(cast) => vis.visit_cast_expr(cast),
         super::ast::ExprKind::IndexExpr(index_expr) => vis.visit_index_expr(index_expr),
         super::ast::ExprKind::Paren(expr) => vis.visit_expr(expr),
+        super::ast::ExprKind::DurationOf(expr) => vis.visit_duration_of_expr(expr),
     }
 }
 
@@ -640,6 +645,12 @@ pub fn walk_cast_expr(vis: &mut impl MutVisitor, expr: &mut Cast) {
     vis.visit_expr(&mut expr.arg);
 }
 
+pub fn walk_duration_of_expr(vis: &mut impl MutVisitor, expr: &mut DurationofCall) {
+    vis.visit_span(&mut expr.span);
+    vis.visit_span(&mut expr.name_span);
+    vis.visit_block(&mut expr.scope);
+}
+
 pub fn walk_index_expr(vis: &mut impl MutVisitor, expr: &mut IndexExpr) {
     vis.visit_span(&mut expr.span);
     vis.visit_expr(&mut expr.collection);

source/compiler/qsc_qasm/src/semantic/ast.rs

@@ -1093,6 +1093,7 @@ pub enum ExprKind {
     Paren(Expr),
     Measure(MeasureExpr),
     SizeofCall(SizeofCallExpr),
+    DurationofCall(DurationofCallExpr),
 }
 
 impl Display for ExprKind {
@@ -1110,6 +1111,7 @@ impl Display for ExprKind {
             ExprKind::Paren(expr) => write!(f, "Paren {expr}"),
             ExprKind::Measure(expr) => write!(f, "{expr}"),
             ExprKind::SizeofCall(call) => write!(f, "{call}"),
+            ExprKind::DurationofCall(call) => write!(f, "{call}"),
         }
     }
 }
@@ -1223,6 +1225,22 @@ impl Display for SizeofCallExpr {
     }
 }
 
+#[derive(Clone, Debug)]
+
+pub struct DurationofCallExpr {
+    pub span: Span,
+    pub fn_name_span: Span,
+    pub scope: Block,
+}
+
+impl Display for DurationofCallExpr {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        writeln_header(f, "DurationofCallExpr", self.span)?;
+        writeln_field(f, "fn_name_span", &self.fn_name_span)?;
+        write_field(f, "scope", &self.scope)
+    }
+}
+
 /// The information in this struct is aimed to be consumed
 /// by the language service. The result of the computation
 /// is already stored in the [`Expr::const_value`] field by

source/compiler/qsc_qasm/src/semantic/const_eval.rs

@@ -128,6 +128,15 @@ impl Expr {
                 // in [`Lowerer::lower_sizeof_call_expr`].
                 None
             }
+            ExprKind::DurationofCall(_) => {
+                // We can't evaluate `durationof` calls, and we can't evaluate the
+                // blocks within them to derive the duration. For type and semantic
+                // checks we assume that the `durationof` call is a const expression
+                // with a 0 duration value.
+                let value = Duration::default();
+                let kind = LiteralKind::Duration(value);
+                Some(kind)
+            }
             ExprKind::Err => None,
         }
     }

source/compiler/qsc_qasm/src/semantic/lowerer.rs

@@ -833,6 +833,7 @@ impl Lowerer {
             syntax::ExprKind::Lit(lit) => self.lower_lit_expr(lit, None),
             syntax::ExprKind::Paren(pexpr) => self.lower_paren_expr(pexpr, expr.span),
             syntax::ExprKind::UnaryOp(expr) => self.lower_unary_op_expr(expr),
+            syntax::ExprKind::DurationOf(expr) => self.lower_duration_of_expr(expr),
         }
     }
 
@@ -1120,6 +1121,17 @@ impl Lowerer {
         }
     }
 
+    fn lower_duration_of_expr(&mut self, expr: &syntax::DurationofCall) -> semantic::Expr {
+        let scope = self.lower_block(&expr.scope);
+        let ty = Type::Duration(true);
+        let kind = semantic::ExprKind::DurationofCall(semantic::DurationofCallExpr {
+            span: expr.span,
+            fn_name_span: expr.name_span,
+            scope,
+        });
+        semantic::Expr::new(expr.span, kind, ty)
+    }
+
     fn lower_annotations(annotations: &[Box<syntax::Annotation>]) -> Vec<semantic::Annotation> {
         annotations
             .iter()
@@ -1277,7 +1289,10 @@ impl Lowerer {
             None => self.cast_expr_with_target_type_or_default(None, &ty, stmt_span),
         };
 
-        if init_expr.ty.is_const() {
+        // If the type is a duration subtype, we need to evaluate the init_expr
+        // to get the const value and set it in the symbol.
+        // This is because duration subtypes can only be const.
+        if type_is_duration_subtype(&init_expr.ty) {
             init_expr = init_expr.with_const_value(self);
             symbol = symbol.with_const_expr(Rc::new(init_expr.clone()));
         }
@@ -3439,6 +3454,7 @@ impl Lowerer {
             }
             Type::BitArray(size, _) => Self::cast_bitarray_expr_to_type(*size, ty, expr),
             Type::Array(..) => Self::cast_array_expr_to_type(ty, expr),
+            Type::Duration(..) | Type::Stretch(..) => cast_duration_subtype_expr_to_type(ty, expr),
             _ => None,
         }
     }
@@ -3894,22 +3910,10 @@ impl Lowerer {
         let left_type = lhs.ty.clone();
         let right_type = rhs.ty.clone();
 
-        // // The spec says that only these operators are allowed on durations and stretches.
-        // if !matches!(
-        //     op,
-        //     syntax::BinOp::Add | syntax::BinOp::Sub | syntax::BinOp::Mul | syntax::BinOp::Div
-        // ) {
-        //     return unsupported_binop(op, left_type, right_type, span);
-        // }
-
         // <https://openqasm.com/language/types.html#converting-duration-to-other-types>
         // Division of two durations results in a machine-precision float
         // No other operations between durations are allowed.
         if both_types_are_duration_subtypes(&left_type, &right_type) {
-            // if op == syntax::BinOp::Mul {
-            //     return unsupported_binop(op, left_type, right_type, span);
-            // }
-
             let ty = if op == syntax::BinOp::Div {
                 // Division of two durations results in a machine-precision float
                 Type::Float(None, true)
@@ -4543,6 +4547,22 @@ fn cast_complex_expr_to_type(ty: &Type, rhs: &semantic::Expr) -> Option<semantic
     None
 }
 
+fn cast_duration_subtype_expr_to_type(ty: &Type, rhs: &semantic::Expr) -> Option<semantic::Expr> {
+    assert!(matches!(rhs.ty, Type::Duration(..) | Type::Stretch(..)));
+
+    // we know the rhs is a duration or a stretch
+    // if the target type is a duration subtype, we can 'cast' it
+    if type_is_duration_subtype(ty) {
+        // duration can only 'cast' to a duration subtype.
+        // We aren't going to actually cast, we just
+        // change the type of the expression.
+        let mut expr = rhs.clone();
+        expr.ty = ty.clone();
+        return Some(expr);
+    }
+    None
+}
+
 fn get_identifier_name(identifier: &syntax::IdentOrIndexedIdent) -> Arc<str> {
     match identifier {
         syntax::IdentOrIndexedIdent::Ident(ident) => ident.name.clone(),