bitstring processing is more efficient

Author: idavis

compiler/qsc_qasm/src/ast_builder.rs

@@ -211,30 +211,13 @@ pub(crate) fn build_lit_result_expr(value: qsc_ast::ast::Result, span: Span) ->
     }
 }
 
-pub(crate) fn build_lit_result_array_expr_from_bitstring<S: AsRef<str>>(
-    bitstring: S,
+pub(crate) fn build_lit_result_array_expr<I: IntoIterator<Item = ast::Result>>(
+    values: I,
     span: Span,
 ) -> Expr {
-    let values = bitstring
-        .as_ref()
-        .chars()
-        .filter_map(|c| {
-            if c == '0' {
-                Some(ast::Result::Zero)
-            } else if c == '1' {
-                Some(ast::Result::One)
-            } else {
-                None
-            }
-        })
-        .collect();
-    build_lit_result_array_expr(values, span)
-}
-
-pub(crate) fn build_lit_result_array_expr(values: Vec<qsc_ast::ast::Result>, span: Span) -> Expr {
     let exprs: Vec<_> = values
         .into_iter()
-        .map(|v| build_lit_result_expr(v, Span::default()))
+        .map(|value| build_lit_result_expr(value, Span::default()))
         .collect();
     build_expr_array_expr(exprs, span)
 }

compiler/qsc_qasm/src/compiler.rs

@@ -24,7 +24,7 @@ use crate::{
         build_if_expr_then_block_else_expr, build_if_expr_then_expr_else_expr,
         build_implicit_return_stmt, build_index_expr, build_indexed_assignment_statement,
         build_lit_angle_expr, build_lit_bigint_expr, build_lit_bool_expr, build_lit_complex_expr,
-        build_lit_double_expr, build_lit_int_expr, build_lit_result_array_expr_from_bitstring,
+        build_lit_double_expr, build_lit_int_expr, build_lit_result_array_expr,
         build_lit_result_expr, build_managed_qubit_alloc, build_math_call_from_exprs,
         build_math_call_no_params, build_measure_call, build_operation_with_stmts,
         build_path_ident_expr, build_path_ident_ty, build_qasm_import_decl,
@@ -1534,12 +1534,29 @@ impl QasmCompiler {
 
     fn compile_bitstring_literal(value: &BigInt, width: u32, span: Span) -> qsast::Expr {
         let width = width as usize;
-        let bitstring = if value == &BigInt::ZERO && width == 0 {
-            "Bitstring(\"\")".to_string()
+        // Handle the special case where the value is zero and width is zero
+        if value == &BigInt::ZERO && width == 0 {
+            return build_lit_result_array_expr(vec![], span);
+        }
+
+        let binary = value.to_str_radix(2).into_bytes().into_iter().map(|b| {
+            // the string bytes are ASCII bytes, so we check their value offset from b'0'
+            if (b - b'0') == 0 {
+                qsast::Result::Zero
+            } else {
+                qsast::Result::One
+            }
+        });
+        // Pad the binary representation with leading zeros to match the width
+        let values = if binary.len() < width {
+            let mut padded = vec![qsast::Result::Zero; width - binary.len()];
+            padded.extend(binary);
+            padded
         } else {
-            format!("Bitstring(\"{:0>width$}\")", value.to_str_radix(2))
+            binary.collect()
         };
-        build_lit_result_array_expr_from_bitstring(bitstring, span)
+
+        build_lit_result_array_expr(values, span)
     }
 
     fn compile_complex_literal(real: f64, imag: f64, span: Span) -> qsast::Expr {

compiler/qsc_qasm/src/tests/fuzz.rs

@@ -113,3 +113,9 @@ fn fuzz_2392() {
     let source = "e[π:";
     compile_qasm_best_effort(source, Profile::Unrestricted);
 }
+
+#[test]
+fn fuzz_2397() {
+    let source = "creg a[551615";
+    compile_qasm_best_effort(source, Profile::Unrestricted);
+}