Support omitted start and stop in ranges (#2472)

Support omitted start and stop in ranges.

Author: orpuente-MS

compiler/qsc_qasm/src/ast_builder.rs

@@ -561,14 +561,19 @@ pub(crate) fn build_array_reverse_expr(expr: Expr) -> Expr {
 }
 
 #[allow(clippy::similar_names)]
-pub(crate) fn build_range_expr(start: Expr, stop: Expr, step: Option<Expr>, span: Span) -> Expr {
+pub(crate) fn build_range_expr(
+    start: Option<Expr>,
+    step: Option<Expr>,
+    stop: Option<Expr>,
+    span: Span,
+) -> Expr {
     Expr {
         id: NodeId::default(),
         span,
         kind: Box::new(ExprKind::Range(
-            Some(Box::new(start)),
+            start.map(Box::new),
             step.map(Box::new),
-            Some(Box::new(stop)),
+            stop.map(Box::new),
         )),
     }
 }

compiler/qsc_qasm/src/compiler.rs

@@ -1506,19 +1506,10 @@ impl QasmCompiler {
     }
 
     fn compile_range_expr(&mut self, range: &semast::Range) -> qsast::Expr {
-        let Some(start) = &range.start else {
-            self.push_unimplemented_error_message("omitted range start", range.span);
-            return err_expr(range.span);
-        };
-        let Some(end) = &range.end else {
-            self.push_unimplemented_error_message("omitted range end", range.span);
-            return err_expr(range.span);
-        };
-
-        let start = self.compile_expr(start);
-        let end = self.compile_expr(end);
+        let start = range.start.as_ref().map(|expr| self.compile_expr(expr));
         let step = range.step.as_ref().map(|expr| self.compile_expr(expr));
-        build_range_expr(start, end, step, range.span)
+        let end = range.end.as_ref().map(|expr| self.compile_expr(expr));
+        build_range_expr(start, step, end, range.span)
     }
 
     fn compile_array_literal(&mut self, array: &Array, span: Span) -> qsast::Expr {

compiler/qsc_qasm/src/parser/stmt.rs

@@ -1205,15 +1205,18 @@ pub fn parse_if_stmt(s: &mut ParserContext) -> Result<IfStmt> {
 /// Ranges in for loops are a bit different. They must have explicit start and end.
 /// Grammar `LBRACKET start=expression COLON (step=expression COLON)? stop=expression]`.
 /// Reference: <https://openqasm.com/language/classical.html#for-loops>.
+///
+/// However, we allow the range to have omitted start and end at this point,
+/// and push a semantic error later at the lowering stage.
 fn for_loop_range_expr(s: &mut ParserContext) -> Result<Range> {
     let lo = s.peek().span.lo;
     token(s, TokenKind::Open(Delim::Bracket))?;
-    let start = Some(expr::expr(s)?);
+    let start = opt(s, expr::expr)?;
     token(s, TokenKind::Colon)?;
 
     // QASM ranges have the pattern [start : (step :)? end]
     // We assume the second expr is the `end`.
-    let mut end = Some(expr::expr(s)?);
+    let mut end = opt(s, expr::expr)?;
     let mut step = None;
 
     // If we find a third expr, then the second expr was the `step`.

compiler/qsc_qasm/src/parser/stmt/tests/for_loops.rs

@@ -143,6 +143,66 @@ fn for_stmt_iterating_over_range_no_step() {
     );
 }
 
+#[test]
+fn for_stmt_iterating_over_range_no_start() {
+    check(
+        parse,
+        "
+    for int x in [:7] {
+        a = 0;
+    }",
+        &expect![[r#"
+            Stmt [5-45]:
+                annotations: <empty>
+                kind: ForStmt [5-45]:
+                    variable_type: ScalarType [9-12]: IntType [9-12]:
+                        size: <none>
+                    variable_name: Ident [13-14] "x"
+                    iterable: Range [18-22]:
+                        start: <none>
+                        step: <none>
+                        end: Expr [20-21]: Lit: Int(7)
+                    body: Stmt [23-45]:
+                        annotations: <empty>
+                        kind: Block [23-45]:
+                            Stmt [33-39]:
+                                annotations: <empty>
+                                kind: AssignStmt [33-39]:
+                                    lhs: Ident [33-34] "a"
+                                    rhs: Expr [37-38]: Lit: Int(0)"#]],
+    );
+}
+
+#[test]
+fn for_stmt_iterating_over_range_no_end() {
+    check(
+        parse,
+        "
+    for int x in [0:] {
+        a = 0;
+    }",
+        &expect![[r#"
+            Stmt [5-45]:
+                annotations: <empty>
+                kind: ForStmt [5-45]:
+                    variable_type: ScalarType [9-12]: IntType [9-12]:
+                        size: <none>
+                    variable_name: Ident [13-14] "x"
+                    iterable: Range [18-22]:
+                        start: Expr [19-20]: Lit: Int(0)
+                        step: <none>
+                        end: <none>
+                    body: Stmt [23-45]:
+                        annotations: <empty>
+                        kind: Block [23-45]:
+                            Stmt [33-39]:
+                                annotations: <empty>
+                                kind: AssignStmt [33-39]:
+                                    lhs: Ident [33-34] "a"
+                                    rhs: Expr [37-38]: Lit: Int(0)"#]],
+    );
+}
+
 #[test]
 fn for_stmt_iterating_over_expr() {
     check(

compiler/qsc_qasm/src/semantic/error.rs

@@ -181,10 +181,10 @@ pub enum SemanticErrorKind {
     #[error("quantum typed values cannot be used in binary expressions")]
     #[diagnostic(code("Qasm.Lowerer.QuantumTypesInBinaryExpression"))]
     QuantumTypesInBinaryExpression(#[label] Span),
-    #[error("range expressions must have a start")]
+    #[error("range expressions must have a start when used in for loops")]
     #[diagnostic(code("Qasm.Lowerer.RangeExpressionsMustHaveStart"))]
     RangeExpressionsMustHaveStart(#[label] Span),
-    #[error("range expressions must have a stop")]
+    #[error("range expressions must have a stop when used in for loops")]
     #[diagnostic(code("Qasm.Lowerer.RangeExpressionsMustHaveStop"))]
     RangeExpressionsMustHaveStop(#[label] Span),
     #[error("redefined symbol: {0}")]

compiler/qsc_qasm/src/semantic/lowerer.rs

@@ -3715,13 +3715,23 @@ impl Lowerer {
         })
     }
 
-    /// Ranges used for array initialization don't need to be const evaluatable
-    /// and can be computed at runtime.
+    /// These ranges as iterators in for loops. The spec says
+    /// that `start` and `stop` are mandatory in this case.
+    ///
+    /// Spec: <https://openqasm.com/language/classical.html#for-loops>
     fn lower_range(&mut self, range: &syntax::Range) -> semantic::Range {
         let start = range.start.as_ref().map(|e| self.lower_expr(e));
         let step = range.step.as_ref().map(|e| self.lower_expr(e));
         let end = range.end.as_ref().map(|e| self.lower_expr(e));
 
+        if start.is_none() {
+            self.push_semantic_error(SemanticErrorKind::RangeExpressionsMustHaveStart(range.span));
+        }
+
+        if end.is_none() {
+            self.push_semantic_error(SemanticErrorKind::RangeExpressionsMustHaveStop(range.span));
+        }
+
         semantic::Range {
             span: range.span,
             start,

compiler/qsc_qasm/src/semantic/tests/statements/for_stmt.rs

@@ -1,7 +1,7 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
-use crate::semantic::tests::check_stmt_kinds;
+use crate::{semantic::tests::check_stmt_kinds, tests::check_qasm_to_qsharp};
 use expect_test::expect;
 
 #[test]
@@ -95,3 +95,47 @@ fn loop_creates_its_own_scope() {
         "#]],
     );
 }
+
+#[test]
+fn omitted_start_in_for_range_fails() {
+    let source = "
+        for int i in [:5] {}
+    ";
+
+    check_qasm_to_qsharp(
+        source,
+        &expect![[r#"
+            Qasm.Lowerer.RangeExpressionsMustHaveStart
+
+              x range expressions must have a start when used in for loops
+               ,-[Test.qasm:2:22]
+             1 | 
+             2 |         for int i in [:5] {}
+               :                      ^^^^
+             3 |     
+               `----
+        "#]],
+    );
+}
+
+#[test]
+fn omitted_end_in_for_range_fails() {
+    let source = "
+        for int i in [1:] {}
+    ";
+
+    check_qasm_to_qsharp(
+        source,
+        &expect![[r#"
+            Qasm.Lowerer.RangeExpressionsMustHaveStop
+
+              x range expressions must have a stop when used in for loops
+               ,-[Test.qasm:2:22]
+             1 | 
+             2 |         for int i in [1:] {}
+               :                      ^^^^
+             3 |     
+               `----
+        "#]],
+    );
+}

compiler/qsc_qasm/src/tests/expression/indexed.rs

@@ -169,3 +169,37 @@ fn index_set_in_non_alias_stmt_fails() {
         ]"#]]
     .assert_eq(&format!("{errors:?}"));
 }
+
+#[test]
+fn indexed_ident_with_omitted_start() {
+    let source = r#"
+        array[int, 5] a;
+        a[:3];
+    "#;
+
+    check_qasm_to_qsharp(
+        source,
+        &expect![[r#"
+            import Std.OpenQASM.Intrinsic.*;
+            mutable a = [0, 0, 0, 0, 0];
+            a[...3];
+        "#]],
+    );
+}
+
+#[test]
+fn indexed_ident_with_omitted_stop() {
+    let source = r#"
+        array[int, 5] a;
+        a[2:];
+    "#;
+
+    check_qasm_to_qsharp(
+        source,
+        &expect![[r#"
+        import Std.OpenQASM.Intrinsic.*;
+        mutable a = [0, 0, 0, 0, 0];
+        a[2...];
+    "#]],
+    );
+}