fix lexer bug

Author: orpuente-MS

compiler/qsc_qasm3/src/lex/cooked.rs

@@ -554,19 +554,14 @@ 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)),
-                    ) => {
+                self.next_if_eq(raw::TokenKind::Whitespace);
+
+                match self.first() {
+                    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();
-                        }
+                        // Consume the fragment.
                         self.next();
 
                         Ok(Some(match fragment {

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

@@ -363,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,35 @@ 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/expr/tests.rs

@@ -4,27 +4,10 @@
 use super::expr;
 use crate::{
     ast::StmtKind,
-    parser::{scan::ParserContext, stmt, tests::check, Parser},
+    parser::{scan::ParserContext, stmt, tests::check},
 };
 use expect_test::{expect, Expect};
 
-fn check_map<T>(
-    mut parser: impl Parser<T>,
-    input: &str,
-    expect: &Expect,
-    f: impl FnOnce(&T) -> String,
-) {
-    let mut scanner = ParserContext::new(input);
-    let result = parser(&mut scanner);
-    let errors = scanner.into_errors();
-    match result {
-        Ok(value) if errors.is_empty() => expect.assert_eq(&f(&value)),
-        Ok(value) => expect.assert_eq(&format!("{}\n\n{errors:#?}", f(&value))),
-        Err(error) if errors.is_empty() => expect.assert_debug_eq(&error),
-        Err(error) => expect.assert_eq(&format!("{error:#?}\n\n{errors:#?}")),
-    }
-}
-
 /// This function checks two things:
 ///   1. That the input `Expr` is parsed correctly.
 ///   2. That if we add a semicolon at the end it parses correctly as a `ExprStmt`