Add missing statements to QASM3 parser

compiler/qsc_qasm3/src/lex/cooked.rs

@@ -100,8 +100,6 @@ pub enum TokenKind {
     NegCtrl,
     Dim,
     DurationOf,
-    Delay,
-    Reset,
     Measure,
 
     Literal(Literal),
@@ -125,6 +123,8 @@ pub enum TokenKind {
     PlusPlus,
     /// `->`
     Arrow,
+    /// `@`
+    At,
 
     // Operators,
     ClosedBinOp(ClosedBinOp),
@@ -157,8 +157,6 @@ impl Display for TokenKind {
             TokenKind::NegCtrl => write!(f, "negctrl"),
             TokenKind::Dim => write!(f, "dim"),
             TokenKind::DurationOf => write!(f, "durationof"),
-            TokenKind::Delay => write!(f, "delay"),
-            TokenKind::Reset => write!(f, "reset"),
             TokenKind::Measure => write!(f, "measure"),
             TokenKind::Literal(literal) => write!(f, "literal `{literal}`"),
             TokenKind::Open(Delim::Brace) => write!(f, "`{{`"),
@@ -173,6 +171,7 @@ impl Display for TokenKind {
             TokenKind::Comma => write!(f, "`,`"),
             TokenKind::PlusPlus => write!(f, "`++`"),
             TokenKind::Arrow => write!(f, "`->`"),
+            TokenKind::At => write!(f, "`@`"),
             TokenKind::ClosedBinOp(op) => write!(f, "`{op}`"),
             TokenKind::BinOpEq(op) => write!(f, "`{op}=`"),
             TokenKind::ComparisonOp(op) => write!(f, "`{op}`"),
@@ -404,6 +403,12 @@ pub(crate) struct Lexer<'a> {
 
     // This uses a `Peekable` iterator over the raw lexer, which allows for one token lookahead.
     tokens: Peekable<raw::Lexer<'a>>,
+
+    /// This flag is used to detect annotations at the
+    /// beginning of a file. Normally annotations are
+    /// detected because there is a Newline followed by an `@`,
+    /// but there is no newline at the beginning of a file.
+    beginning_of_file: bool,
 }
 
 impl<'a> Lexer<'a> {
@@ -415,6 +420,7 @@ impl<'a> Lexer<'a> {
                 .try_into()
                 .expect("input length should fit into u32"),
             tokens: raw::Lexer::new(input).peekable(),
+            beginning_of_file: true,
         }
     }
 
@@ -455,14 +461,6 @@ impl<'a> Lexer<'a> {
         self.tokens.peek().map(|i| i.kind)
     }
 
-    /// Returns the second token ahead of the cursor without consuming it. This is slower
-    /// than [`first`] and should be avoided when possible.
-    fn second(&self) -> Option<raw::TokenKind> {
-        let mut tokens = self.tokens.clone();
-        tokens.next();
-        tokens.next().map(|i| i.kind)
-    }
-
     /// Consumes the characters while they satisfy `f`. Returns the last character eaten, if any.
     fn eat_while(&mut self, mut f: impl FnMut(raw::TokenKind) -> bool) -> Option<raw::TokenKind> {
         let mut last_eaten: Option<raw::Token> = None;
@@ -503,8 +501,27 @@ impl<'a> Lexer<'a> {
                     hi: token.offset,
                 }))
             }
-            raw::TokenKind::Comment(_) | raw::TokenKind::Newline | raw::TokenKind::Whitespace => {
-                Ok(None)
+            raw::TokenKind::Comment(_) | raw::TokenKind::Whitespace => Ok(None),
+            raw::TokenKind::Newline => {
+                // AnnotationKeyword: '@' Identifier ('.' Identifier)* ->  pushMode(EAT_TO_LINE_END);
+                self.next_if_eq(raw::TokenKind::Whitespace);
+                match self.tokens.peek() {
+                    Some(token) if token.kind == raw::TokenKind::Single(Single::At) => {
+                        let token = self.tokens.next().expect("self.tokens.peek() was Some(_)");
+                        let complete = TokenKind::Annotation;
+                        self.expect(raw::TokenKind::Ident, complete);
+                        self.eat_to_end_of_line();
+                        let kind = Some(complete);
+                        return Ok(kind.map(|kind| {
+                            let span = Span {
+                                lo: token.offset,
+                                hi: self.offset(),
+                            };
+                            Token { kind, span }
+                        }));
+                    }
+                    _ => Ok(None),
+                }
             }
             raw::TokenKind::Ident => {
                 let ident = &self.input[(token.offset as usize)..(self.offset() as usize)];
@@ -529,31 +546,31 @@ impl<'a> Lexer<'a> {
             raw::TokenKind::Number(number) => {
                 // after reading a decimal number or a float there could be a whitespace
                 // followed by a fragment, which will change the type of the literal.
-                match (self.first(), self.second()) {
-                    (Some(raw::TokenKind::LiteralFragment(fragment)), _)
-                    | (
-                        Some(raw::TokenKind::Whitespace),
-                        Some(raw::TokenKind::LiteralFragment(fragment)),
-                    ) => {
-                        use self::Literal::{Imaginary, Timing};
-                        use TokenKind::Literal;
-
-                        // if first() was a whitespace, we need to consume an extra token
-                        if self.first() == Some(raw::TokenKind::Whitespace) {
-                            self.next();
-                        }
-                        self.next();
-
-                        Ok(Some(match fragment {
-                            raw::LiteralFragmentKind::Imag => Literal(Imaginary),
-                            raw::LiteralFragmentKind::Dt => Literal(Timing(TimingLiteralKind::Dt)),
-                            raw::LiteralFragmentKind::Ns => Literal(Timing(TimingLiteralKind::Ns)),
-                            raw::LiteralFragmentKind::Us => Literal(Timing(TimingLiteralKind::Us)),
-                            raw::LiteralFragmentKind::Ms => Literal(Timing(TimingLiteralKind::Ms)),
-                            raw::LiteralFragmentKind::S => Literal(Timing(TimingLiteralKind::S)),
-                        }))
-                    }
-                    _ => Ok(Some(number.into())),
+                let numeric_part_hi = self.offset();
+                self.next_if_eq(raw::TokenKind::Whitespace);
+
+                if let Some(raw::TokenKind::LiteralFragment(fragment)) = self.first() {
+                    use self::Literal::{Imaginary, Timing};
+                    use TokenKind::Literal;
+
+                    // Consume the fragment.
+                    self.next();
+
+                    Ok(Some(match fragment {
+                        raw::LiteralFragmentKind::Imag => Literal(Imaginary),
+                        raw::LiteralFragmentKind::Dt => Literal(Timing(TimingLiteralKind::Dt)),
+                        raw::LiteralFragmentKind::Ns => Literal(Timing(TimingLiteralKind::Ns)),
+                        raw::LiteralFragmentKind::Us => Literal(Timing(TimingLiteralKind::Us)),
+                        raw::LiteralFragmentKind::Ms => Literal(Timing(TimingLiteralKind::Ms)),
+                        raw::LiteralFragmentKind::S => Literal(Timing(TimingLiteralKind::S)),
+                    }))
+                } else {
+                    let kind: TokenKind = number.into();
+                    let span = Span {
+                        lo: token.offset,
+                        hi: numeric_part_hi,
+                    };
+                    return Ok(Some(Token { kind, span }));
                 }
             }
             raw::TokenKind::Single(Single::Sharp) => {
@@ -620,11 +637,14 @@ impl<'a> Lexer<'a> {
                 }
             }
             Single::At => {
-                // AnnotationKeyword: '@' Identifier ('.' Identifier)* ->  pushMode(EAT_TO_LINE_END);
-                let complete = TokenKind::Annotation;
-                self.expect(raw::TokenKind::Ident, complete);
-                self.eat_to_end_of_line();
-                Ok(complete)
+                if self.beginning_of_file {
+                    let complete = TokenKind::Annotation;
+                    self.expect(raw::TokenKind::Ident, complete);
+                    self.eat_to_end_of_line();
+                    Ok(complete)
+                } else {
+                    Ok(TokenKind::At)
+                }
             }
             Single::Bang => {
                 if self.next_if_eq_single(Single::Eq) {
@@ -717,8 +737,6 @@ impl<'a> Lexer<'a> {
             "negctrl" => TokenKind::NegCtrl,
             "dim" => TokenKind::Dim,
             "durationof" => TokenKind::DurationOf,
-            "delay" => TokenKind::Delay,
-            "reset" => TokenKind::Reset,
             "measure" => TokenKind::Measure,
             ident => {
                 if let Ok(keyword) = ident.parse::<Keyword>() {
@@ -739,9 +757,15 @@ impl Iterator for Lexer<'_> {
     fn next(&mut self) -> Option<Self::Item> {
         while let Some(token) = self.tokens.next() {
             match self.cook(&token) {
-                Ok(None) => {}
-                Ok(Some(token)) => return Some(Ok(token)),
-                Err(err) => return Some(Err(err)),
+                Ok(None) => self.beginning_of_file = false,
+                Ok(Some(token)) => {
+                    self.beginning_of_file = false;
+                    return Some(Ok(token));
+                }
+                Err(err) => {
+                    self.beginning_of_file = false;
+                    return Some(Err(err));
+                }
             }
         }
 

compiler/qsc_qasm3/src/lex/cooked/tests.rs

@@ -35,11 +35,10 @@ fn op_string(kind: TokenKind) -> Option<String> {
         TokenKind::NegCtrl => Some("negctrl".to_string()),
         TokenKind::Dim => Some("dim".to_string()),
         TokenKind::DurationOf => Some("durationof".to_string()),
-        TokenKind::Delay => Some("delay".to_string()),
-        TokenKind::Reset => Some("reset".to_string()),
         TokenKind::Measure => Some("measure".to_string()),
         TokenKind::Semicolon => Some(";".to_string()),
         TokenKind::Arrow => Some("->".to_string()),
+        TokenKind::At => Some("@".to_string()),
         TokenKind::ClosedBinOp(op) => Some(op.to_string()),
         TokenKind::BinOpEq(super::ClosedBinOp::AmpAmp | super::ClosedBinOp::BarBar)
         | TokenKind::Literal(_)
@@ -364,6 +363,37 @@ fn imag_with_whitespace() {
     );
 }
 
+#[test]
+fn imag_with_whitespace_semicolon() {
+    check(
+        "123 im;",
+        &expect![[r#"
+            [
+                Ok(
+                    Token {
+                        kind: Literal(
+                            Imaginary,
+                        ),
+                        span: Span {
+                            lo: 0,
+                            hi: 6,
+                        },
+                    },
+                ),
+                Ok(
+                    Token {
+                        kind: Semicolon,
+                        span: Span {
+                            lo: 6,
+                            hi: 7,
+                        },
+                    },
+                ),
+            ]
+        "#]],
+    );
+}
+
 #[test]
 fn negative_imag() {
     check(

compiler/qsc_qasm3/src/lex/raw/tests.rs

@@ -1274,3 +1274,38 @@ fn hardware_qubit_with_underscore_in_the_middle() {
         "#]],
     );
 }
+
+#[test]
+fn decimal_space_imag_semicolon() {
+    check(
+        "10  im;",
+        &expect![[r#"
+        [
+            Token {
+                kind: Number(
+                    Int(
+                        Decimal,
+                    ),
+                ),
+                offset: 0,
+            },
+            Token {
+                kind: Whitespace,
+                offset: 2,
+            },
+            Token {
+                kind: LiteralFragment(
+                    Imag,
+                ),
+                offset: 4,
+            },
+            Token {
+                kind: Single(
+                    Semi,
+                ),
+                offset: 6,
+            },
+        ]
+    "#]],
+    );
+}

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

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

compiler/qsc_qasm3/src/parser/error.rs

@@ -101,6 +101,9 @@ pub enum ErrorKind {
     #[error("expected {0}, found {1}")]
     #[diagnostic(code("Qasm3.Parse.Rule"))]
     Rule(&'static str, TokenKind, #[label] Span),
+    #[error("invalid classical statement in box")]
+    #[diagnostic(code("Qasm3.Parse.ClassicalStmtInBox"))]
+    ClassicalStmtInBox(#[label] Span),
     #[error("expected {0}, found {1}")]
     #[diagnostic(code("Qasm3.Parse.Convert"))]
     Convert(&'static str, &'static str, #[label] Span),
@@ -119,9 +122,18 @@ pub enum ErrorKind {
     #[error("missing switch statement case labels")]
     #[diagnostic(code("Qasm3.Parse.MissingSwitchCaseLabels"))]
     MissingSwitchCaseLabels(#[label] Span),
+    #[error("missing switch statement case labels")]
+    #[diagnostic(code("Qasm3.Parse.MissingGateCallOperands"))]
+    MissingGateCallOperands(#[label] Span),
     #[error("expected an item or closing brace, found {0}")]
     #[diagnostic(code("Qasm3.Parse.ExpectedItem"))]
     ExpectedItem(TokenKind, #[label] Span),
+    #[error("gphase gate requires exactly one angle")]
+    #[diagnostic(code("Qasm3.Parse.GPhaseInvalidArguments"))]
+    GPhaseInvalidArguments(#[label] Span),
+    #[error("invalid gate call designator")]
+    #[diagnostic(code("Qasm3.Parse.InvalidGateCallDesignator"))]
+    InvalidGateCallDesignator(#[label] Span),
 }
 
 impl ErrorKind {
@@ -132,14 +144,18 @@ impl ErrorKind {
             Self::Escape(ch, span) => Self::Escape(ch, span + offset),
             Self::Token(expected, actual, span) => Self::Token(expected, actual, span + offset),
             Self::Rule(name, token, span) => Self::Rule(name, token, span + offset),
+            Self::ClassicalStmtInBox(span) => Self::ClassicalStmtInBox(span + offset),
             Self::Convert(expected, actual, span) => Self::Convert(expected, actual, span + offset),
             Self::MissingSemi(span) => Self::MissingSemi(span + offset),
             Self::MissingParens(span) => Self::MissingParens(span + offset),
             Self::FloatingAnnotation(span) => Self::FloatingAnnotation(span + offset),
             Self::MissingSeqEntry(span) => Self::MissingSeqEntry(span + offset),
             Self::MissingSwitchCases(span) => Self::MissingSwitchCases(span + offset),
             Self::MissingSwitchCaseLabels(span) => Self::MissingSwitchCaseLabels(span + offset),
+            Self::MissingGateCallOperands(span) => Self::MissingGateCallOperands(span + offset),
             Self::ExpectedItem(token, span) => Self::ExpectedItem(token, span + offset),
+            Self::GPhaseInvalidArguments(span) => Self::GPhaseInvalidArguments(span + offset),
+            Self::InvalidGateCallDesignator(span) => Self::InvalidGateCallDesignator(span + offset),
         }
     }
 }