Add support for array concatenation in OpenQASM (#2676)

This PR adds support for [array concatenation in
OpenQASM](https://openqasm.com/versions/3.0/language/types.html#array-concatenation-and-slicing).

### Notes

Array concatenation does not appear in the Grammar and is underspecified
in the Spec. This implementation is conservative in two senses while we
wait for Spec clarification:
1. We don't allow concatenating arrays of different base types, even if
they differ only in width.
2. We don't allow mixing together arrays, static array references, and
dynamic array references.

---------

Co-authored-by: Ian Davis <[email protected]>

Author: orpuente-MS

source/compiler/qsc_qasm/src/compiler.rs

@@ -620,6 +620,34 @@ impl QasmCompiler {
         Some(decl)
     }
 
+    fn compile_concat_expr(&mut self, expr: &semast::ConcatExpr) -> qsast::Expr {
+        let exprs = expr
+            .operands
+            .iter()
+            .map(|expr| self.compile_expr(expr))
+            .collect::<Vec<_>>();
+
+        assert!(
+            exprs.len() >= 2,
+            "the parser guarantees that a concat expression has at least two operands"
+        );
+
+        let mut expr_iter = exprs.into_iter();
+        let mut expr = expr_iter
+            .next()
+            .expect("concat exprs must have at least one expression");
+
+        for rhs in expr_iter {
+            let span = Span {
+                lo: expr.span.lo,
+                hi: rhs.span.hi,
+            };
+            expr = build_binary_expr(false, qsast::BinOp::Add, expr, rhs, span);
+        }
+
+        expr
+    }
+
     fn compile_assign_stmt(&mut self, stmt: &semast::AssignStmt) -> Option<qsast::Stmt> {
         let lhs = self.compile_expr(&stmt.lhs);
         let rhs = self.compile_expr(&stmt.rhs);
@@ -1506,6 +1534,7 @@ 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::Concat(concat) => self.compile_concat_expr(concat),
             semast::ExprKind::DurationofCall(duration_call) => {
                 self.compile_durationof_call_expr(duration_call)
             }

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

@@ -241,6 +241,23 @@ impl Display for MeasureExpr {
     }
 }
 
+/// This expression is not part of the expression tree
+/// and is only used as rhs of alias, classical declaration,
+/// and assignment statements.
+/// Grammar: `expression (DOUBLE_PLUS expression)*`.
+#[derive(Clone, Debug)]
+pub struct ConcatExpr {
+    pub span: Span,
+    pub operands: List<Expr>,
+}
+
+impl Display for ConcatExpr {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        writeln_header(f, "ConcatExpr", self.span)?;
+        write_list_field(f, "operands", &self.operands)
+    }
+}
+
 /// A binary operator.
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
 pub enum BinOp {
@@ -1400,15 +1417,19 @@ impl Display for ClassicalDeclarationStmt {
     }
 }
 
+/// A special kind of Expr that allows measurement and concatenation expressions.
+/// It is used as the rhs of alias, classical declaration, and assign statements.
 #[derive(Clone, Debug)]
 pub enum ValueExpr {
+    Concat(ConcatExpr),
     Expr(Expr),
     Measurement(MeasureExpr),
 }
 
 impl Display for ValueExpr {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         match self {
+            Self::Concat(expr) => write!(f, "{expr}"),
             Self::Expr(expr) => write!(f, "{expr}"),
             Self::Measurement(measure) => write!(f, "{measure}"),
         }

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

@@ -17,7 +17,10 @@ use crate::{
         ClosedBinOp, Delim, Radix, Token, TokenKind,
         cooked::{ComparisonOp, Literal, TimingLiteralKind},
     },
-    parser::{ast::DurationofCall, stmt::parse_block},
+    parser::{
+        ast::{ConcatExpr, DurationofCall, List},
+        stmt::parse_block,
+    },
 };
 
 use crate::parser::Result;
@@ -26,7 +29,7 @@ use super::{
     ast::{
         BinOp, BinaryOpExpr, Cast, Expr, ExprKind, FunctionCall, GateOperand, GateOperandKind,
         HardwareQubit, Ident, IdentOrIndexedIdent, Index, IndexExpr, IndexList, IndexListItem,
-        IndexedIdent, List, Lit, LiteralKind, MeasureExpr, Range, Set, TimeUnit, TypeDef, UnaryOp,
+        IndexedIdent, Lit, LiteralKind, MeasureExpr, Range, Set, TimeUnit, TypeDef, UnaryOp,
         UnaryOpExpr, ValueExpr, Version, list_from_iter,
     },
     completion::word_kinds::WordKinds,
@@ -700,18 +703,42 @@ fn lit_array_element(s: &mut ParserContext) -> Result<Expr> {
 
 /// These are expressions allowed in classical declarations.
 /// Grammar: `arrayLiteral | expression | measureExpression`.
+///
+/// The Grammar and this comment don't match, since there is a bug in
+/// the Grammar. Here is a link to the issue:
+/// <https://github.com/openqasm/openqasm/issues/620>
 pub(super) fn declaration_expr(s: &mut ParserContext) -> Result<ValueExpr> {
+    let lo = s.peek().span.lo;
+
+    // 1. Try to parse a measurement expression.
     if let Some(measurement) = opt(s, measure_expr)? {
         return Ok(ValueExpr::Measurement(measurement));
     }
 
-    let expr = if let Some(expr) = opt(s, expr)? {
-        expr
-    } else {
-        lit_array(s)?
-    };
+    // Try to parse an expression or a concatenation.
+    if let Some(e) = opt(s, expr)? {
+        let mut exprs = Vec::new();
+        exprs.push(e);
 
-    Ok(ValueExpr::Expr(expr))
+        // Try to parse many expressions separated by the `++` operator.
+        while opt(s, |s| token(s, TokenKind::PlusPlus))?.is_some() {
+            exprs.push(expr(s)?);
+        }
+
+        // If we parsed a single expression, this is just an `Expr`.
+        if exprs.len() == 1 {
+            return Ok(ValueExpr::Expr(
+                exprs.into_iter().next().expect("there is one element"),
+            ));
+        }
+
+        // If we parsed more than one expression, this is a concatenation.
+        let span = s.span(lo);
+        let operands = list_from_iter(exprs);
+        return Ok(ValueExpr::Concat(ConcatExpr { span, operands }));
+    }
+
+    Ok(ValueExpr::Expr(lit_array(s)?))
 }
 
 /// These are expressions allowed in constant classical declarations.
@@ -728,16 +755,6 @@ pub(super) fn const_declaration_expr(s: &mut ParserContext) -> Result<ValueExpr>
     Ok(ValueExpr::Expr(expr))
 }
 
-/// These are expressions allowed in `Assign`, `AssignOp`, and return stmts.
-/// Grammar: `expression | measureExpression`.
-pub(super) fn expr_or_measurement(s: &mut ParserContext) -> Result<ValueExpr> {
-    if let Some(measurement) = opt(s, measure_expr)? {
-        return Ok(ValueExpr::Measurement(measurement));
-    }
-
-    Ok(ValueExpr::Expr(expr(s)?))
-}
-
 pub(crate) fn expr_list(s: &mut ParserContext) -> Result<Vec<Expr>> {
     seq(s, expr).map(|pair| pair.0)
 }

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

@@ -2,6 +2,7 @@
 // Licensed under the MIT License.
 
 use super::expr;
+use crate::parser::stmt::parse as stmt;
 use crate::{
     parser::ast::StmtKind,
     parser::{scan::ParserContext, stmt, tests::check},
@@ -1211,3 +1212,31 @@ fn duration_of() {
                                     kind: HardwareQubit [21-23]: 0"#]],
     );
 }
+
+#[test]
+fn array_concatenation_is_not_part_of_the_expr_tree() {
+    let source = "a ++ b;";
+
+    check(
+        stmt,
+        source,
+        &expect![[r#"
+        Stmt [0-1]:
+            annotations: <empty>
+            kind: ExprStmt [0-1]:
+                expr: Expr [0-1]: Ident [0-1] "a"
+
+        [
+            Error(
+                Token(
+                    Semicolon,
+                    PlusPlus,
+                    Span {
+                        lo: 2,
+                        hi: 4,
+                    },
+                ),
+            ),
+        ]"#]],
+    );
+}

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, DurationofCall, QubitType};
+use crate::parser::ast::{ConcatExpr, DefParameter, DefParameterType, DurationofCall, QubitType};
 
 use super::ast::{
     AccessControl, AliasDeclStmt, Annotation, ArrayBaseTypeKind, ArrayReferenceType, ArrayType,
@@ -203,6 +203,10 @@ pub trait MutVisitor: Sized {
         walk_measure_expr(self, expr);
     }
 
+    fn visit_concat_expr(&mut self, expr: &mut ConcatExpr) {
+        walk_concat_expr(self, expr);
+    }
+
     fn visit_ident_or_indexed_ident(&mut self, ident: &mut IdentOrIndexedIdent) {
         walk_ident_or_indexed_ident(self, ident);
     }
@@ -659,6 +663,7 @@ pub fn walk_index_expr(vis: &mut impl MutVisitor, expr: &mut IndexExpr) {
 
 pub fn walk_value_expr(vis: &mut impl MutVisitor, expr: &mut ValueExpr) {
     match &mut *expr {
+        ValueExpr::Concat(expr) => vis.visit_concat_expr(expr),
         ValueExpr::Expr(expr) => vis.visit_expr(expr),
         ValueExpr::Measurement(measure_expr) => vis.visit_measure_expr(measure_expr),
     }
@@ -670,6 +675,13 @@ pub fn walk_measure_expr(vis: &mut impl MutVisitor, expr: &mut MeasureExpr) {
     vis.visit_gate_operand(&mut expr.operand);
 }
 
+pub fn walk_concat_expr(vis: &mut impl MutVisitor, expr: &mut ConcatExpr) {
+    vis.visit_span(&mut expr.span);
+    expr.operands
+        .iter_mut()
+        .for_each(|expr| vis.visit_expr(expr));
+}
+
 pub fn walk_ident_or_indexed_ident(vis: &mut impl MutVisitor, ident: &mut IdentOrIndexedIdent) {
     match ident {
         IdentOrIndexedIdent::Ident(ident) => vis.visit_ident(ident),

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

@@ -221,7 +221,7 @@ fn disambiguate_ident(
     let lo = ident_or_indexed_ident.span().lo;
     if s.peek().kind == TokenKind::Eq {
         s.advance();
-        let expr = expr::expr_or_measurement(s)?;
+        let expr = expr::declaration_expr(s)?;
         recovering_semi(s);
         Ok(StmtKind::Assign(AssignStmt {
             span: s.span(lo),
@@ -231,7 +231,7 @@ fn disambiguate_ident(
     } else if let TokenKind::BinOpEq(op) = s.peek().kind {
         s.advance();
         let op = expr::closed_bin_op(op);
-        let expr = expr::expr_or_measurement(s)?;
+        let expr = expr::declaration_expr(s)?;
         recovering_semi(s);
         Ok(StmtKind::AssignOp(AssignOpStmt {
             span: s.span(lo),
@@ -805,7 +805,7 @@ fn gate_params(s: &mut ParserContext<'_>) -> Result<Vec<SeqItem<Ident>>> {
 fn parse_return(s: &mut ParserContext) -> Result<StmtKind> {
     let lo = s.peek().span.lo;
     token(s, TokenKind::Keyword(crate::keyword::Keyword::Return))?;
-    let expr = opt(s, expr::expr_or_measurement)?.map(Box::new);
+    let expr = opt(s, expr::declaration_expr)?.map(Box::new);
     recovering_semi(s);
     Ok(StmtKind::Return(ReturnStmt {
         span: s.span(lo),

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

@@ -855,6 +855,7 @@ pub enum ExprKind {
     Measure(MeasureExpr),
     SizeofCall(SizeofCallExpr),
     DurationofCall(DurationofCallExpr),
+    Concat(ConcatExpr),
 }
 
 impl Display for ExprKind {
@@ -874,6 +875,7 @@ impl Display for ExprKind {
             ExprKind::Measure(expr) => write!(f, "{expr}"),
             ExprKind::SizeofCall(call) => write!(f, "{call}"),
             ExprKind::DurationofCall(call) => write!(f, "{call}"),
+            ExprKind::Concat(expr) => write!(f, "{expr}"),
         }
     }
 }
@@ -1205,6 +1207,19 @@ impl Display for Cast {
     }
 }
 
+#[derive(Clone, Debug)]
+pub struct ConcatExpr {
+    pub span: Span,
+    pub operands: List<Expr>,
+}
+
+impl Display for ConcatExpr {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        writeln_header(f, "ConcatExpr", self.span)?;
+        write_list_field(f, "operands", &self.operands)
+    }
+}
+
 #[derive(Clone, Debug)]
 pub struct IndexedExpr {
     pub span: Span,

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

@@ -127,6 +127,11 @@ impl Expr {
                 // in [`Lowerer::lower_sizeof_call_expr`].
                 None
             }
+            ExprKind::Concat(_) => {
+                // Arrays are non-const, so we don't need to implement array
+                // concatenation in the const-evaluator.
+                None
+            }
             ExprKind::DurationofCall(expr) => Some(LiteralKind::Duration(expr.duration)),
             ExprKind::Err => None,
         }

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

@@ -169,6 +169,9 @@ pub enum SemanticErrorKind {
     #[error("inconsistent types in alias expression: {0}")]
     #[diagnostic(code("Qasm.Lowerer.InconsistentTypesInAlias"))]
     InconsistentTypesInAlias(String, #[label] Span),
+    #[error("inconsistent types in array concatenation expression: {0}")]
+    #[diagnostic(code("Qasm.Lowerer.InconsistentTypesInArrayConcatenation"))]
+    InconsistentTypesInArrayConcatenation(String, #[label] Span),
     #[error("indexed must be a single expression")]
     #[diagnostic(code("Qasm.Lowerer.IndexMustBeSingleExpr"))]
     IndexMustBeSingleExpr(#[label] Span),
@@ -181,6 +184,9 @@ pub enum SemanticErrorKind {
     #[error("assigning {0} values to {1} must be in a range that can be converted to {1}")]
     #[diagnostic(code("Qasm.Lowerer.InvalidCastValueRange"))]
     InvalidCastValueRange(String, String, #[label] Span),
+    #[error("concatenation expressions are not allowed in {0}")]
+    #[diagnostic(code("Qasm.Lowerer.InvalidConcatenationPosition"))]
+    InvalidConcatenationPosition(String, #[label] Span),
     #[error("gate operands other than qubits or qubit arrays are not supported")]
     #[diagnostic(code("Qasm.Lowerer.InvalidGateOperand"))]
     InvalidGateOperand(#[label] Span),
@@ -203,6 +209,10 @@ pub enum SemanticErrorKind {
     #[diagnostic(code("Qasm.Lowerer.InvalidTypeInAlias"))]
     #[diagnostic(help("aliases can only be applied to quantum bits and registers"))]
     InvalidTypeInAlias(String, #[label] Span),
+    #[error("invalid type in array concatenation expression: {0}")]
+    #[diagnostic(code("Qasm.Lowerer.InvalidTypeInArrayConcatenation"))]
+    #[diagnostic(help("array concatenation can only be applied to arrays"))]
+    InvalidTypeInArrayConcatenation(String, #[label] Span),
     #[error("measure statements must have a name")]
     #[diagnostic(code("Qasm.Lowerer.MeasureExpressionsMustHaveName"))]
     MeasureExpressionsMustHaveName(#[label] Span),