functions and operations with const eval (#2270)

Compile functions and operations const evaluating any references to
symbol in an external scope.

Author: orpuente-MS

compiler/qsc_qasm3/src/ast_builder.rs

@@ -7,9 +7,9 @@ use num_bigint::BigInt;
 
 use qsc_ast::ast::{
     self, Attr, Block, CallableBody, CallableDecl, CallableKind, Expr, ExprKind, FieldAssign,
-    Ident, ImportOrExportDecl, ImportOrExportItem, Item, ItemKind, Lit, Mutability, NodeId, Pat,
-    PatKind, Path, PathKind, QubitInit, QubitInitKind, QubitSource, Stmt, StmtKind, TopLevelNode,
-    Ty, TyKind,
+    FunctorExpr, FunctorExprKind, Ident, ImportOrExportDecl, ImportOrExportItem, Item, ItemKind,
+    Lit, Mutability, NodeId, Pat, PatKind, Path, PathKind, QubitInit, QubitInitKind, QubitSource,
+    Stmt, StmtKind, TopLevelNode, Ty, TyKind,
 };
 use qsc_data_structures::span::Span;
 
@@ -1691,6 +1691,108 @@ pub(crate) fn build_lambda<S: AsRef<str>>(
     }
 }
 
+#[allow(clippy::too_many_arguments, clippy::too_many_lines)]
+pub(crate) fn build_function_or_operation(
+    name: String,
+    cargs: Vec<(String, Ty, Pat)>,
+    qargs: Vec<(String, Ty, Pat)>,
+    body: Option<Block>,
+    name_span: Span,
+    body_span: Span,
+    gate_span: Span,
+    return_type: Option<Ty>,
+    kind: CallableKind,
+    functors: Option<FunctorExpr>,
+) -> Stmt {
+    let args = cargs
+        .into_iter()
+        .chain(qargs)
+        .map(|(_, _, pat)| Box::new(pat))
+        .collect::<Vec<_>>();
+
+    let lo = args
+        .iter()
+        .min_by_key(|x| x.span.lo)
+        .map(|x| x.span.lo)
+        .unwrap_or_default();
+
+    let hi = args
+        .iter()
+        .max_by_key(|x| x.span.hi)
+        .map(|x| x.span.hi)
+        .unwrap_or_default();
+
+    let input_pat_kind = if args.len() == 1 {
+        PatKind::Paren(args[0].clone())
+    } else {
+        PatKind::Tuple(args.into_boxed_slice())
+    };
+
+    let input_pat = Pat {
+        kind: Box::new(input_pat_kind),
+        span: Span { lo, hi },
+        ..Default::default()
+    };
+
+    let return_type = if let Some(ty) = return_type {
+        ty
+    } else {
+        build_path_ident_ty("Unit")
+    };
+
+    let body = CallableBody::Block(Box::new(body.unwrap_or_else(|| Block {
+        id: NodeId::default(),
+        span: body_span,
+        stmts: Box::new([]),
+    })));
+
+    let decl = CallableDecl {
+        id: NodeId::default(),
+        span: name_span,
+        kind,
+        name: Box::new(Ident {
+            name: name.into(),
+            ..Default::default()
+        }),
+        generics: Box::new([]),
+        input: Box::new(input_pat),
+        output: Box::new(return_type),
+        functors: functors.map(Box::new),
+        body: Box::new(body),
+    };
+    let item = Item {
+        span: gate_span,
+        kind: Box::new(ast::ItemKind::Callable(Box::new(decl))),
+        ..Default::default()
+    };
+
+    Stmt {
+        kind: Box::new(StmtKind::Item(Box::new(item))),
+        span: gate_span,
+        ..Default::default()
+    }
+}
+
+pub(crate) fn build_adj_plus_ctl_functor() -> FunctorExpr {
+    let adj = Box::new(FunctorExpr {
+        kind: Box::new(FunctorExprKind::Lit(ast::Functor::Adj)),
+        id: Default::default(),
+        span: Default::default(),
+    });
+
+    let ctl = Box::new(FunctorExpr {
+        kind: Box::new(FunctorExprKind::Lit(ast::Functor::Ctl)),
+        id: Default::default(),
+        span: Default::default(),
+    });
+
+    FunctorExpr {
+        kind: Box::new(FunctorExprKind::BinOp(ast::SetOp::Union, adj, ctl)),
+        id: Default::default(),
+        span: Default::default(),
+    }
+}
+
 fn build_idents(idents: &[&str]) -> Option<Box<[Ident]>> {
     let idents = idents
         .iter()

compiler/qsc_qasm3/src/compiler.rs

@@ -10,20 +10,22 @@ use qsc_frontend::{compile::SourceMap, error::WithSource};
 
 use crate::{
     ast_builder::{
-        build_arg_pat, build_array_reverse_expr, build_assignment_statement, build_barrier_call,
-        build_binary_expr, build_call_no_params, build_call_with_param, build_call_with_params,
-        build_cast_call_by_name, build_classical_decl, build_complex_from_expr,
-        build_convert_call_expr, build_expr_array_expr, build_for_stmt, build_gate_call_param_expr,
-        build_gate_call_with_params_and_callee, build_global_call_with_two_params,
-        build_if_expr_then_block, build_if_expr_then_block_else_block,
-        build_if_expr_then_block_else_expr, build_if_expr_then_expr_else_expr,
-        build_implicit_return_stmt, build_indexed_assignment_statement, build_lambda,
-        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_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_qasm_import_decl, build_qasm_import_items, build_range_expr,
-        build_reset_call, build_return_expr, build_return_unit, build_stmt_semi_from_expr,
+        build_adj_plus_ctl_functor, build_arg_pat, build_array_reverse_expr,
+        build_assignment_statement, build_barrier_call, build_binary_expr, build_call_no_params,
+        build_call_with_param, build_call_with_params, build_cast_call_by_name,
+        build_classical_decl, build_complex_from_expr, build_convert_call_expr,
+        build_expr_array_expr, build_for_stmt, build_function_or_operation,
+        build_gate_call_param_expr, build_gate_call_with_params_and_callee,
+        build_global_call_with_two_params, build_if_expr_then_block,
+        build_if_expr_then_block_else_block, build_if_expr_then_block_else_expr,
+        build_if_expr_then_expr_else_expr, build_implicit_return_stmt,
+        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_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_qasm_import_decl, build_qasm_import_items, build_range_expr, build_reset_call,
+        build_return_expr, build_return_unit, build_stmt_semi_from_expr,
         build_stmt_semi_from_expr_with_span, build_top_level_ns_with_items, build_tuple_expr,
         build_unary_op_expr, build_unmanaged_qubit_alloc, build_unmanaged_qubit_alloc_array,
         build_while_stmt, build_wrapped_block_expr, managed_qubit_alloc_array,
@@ -627,7 +629,7 @@ impl QasmCompiler {
 
         // We use the same primitives used for declaring gates, because def declarations
         // in QASM3 can take qubits as arguments and call quantum gates.
-        Some(build_lambda(
+        Some(build_function_or_operation(
             name,
             cargs,
             vec![],
@@ -637,6 +639,7 @@ impl QasmCompiler {
             stmt.span,
             return_type,
             kind,
+            None,
         ))
     }
 
@@ -899,7 +902,7 @@ impl QasmCompiler {
 
         let body = Some(self.compile_block(&stmt.body));
 
-        Some(build_lambda(
+        Some(build_function_or_operation(
             name,
             cargs,
             qargs,
@@ -909,6 +912,7 @@ impl QasmCompiler {
             stmt.span,
             None,
             qsast::CallableKind::Operation,
+            Some(build_adj_plus_ctl_functor()),
         ))
     }
 

compiler/qsc_qasm3/src/semantic/lowerer.rs

@@ -257,7 +257,7 @@ impl Lowerer {
             gate_symbol("cx", 0, 2),
             gate_symbol("cy", 0, 2),
             gate_symbol("cz", 0, 2),
-            gate_symbol("cp", 0, 2),
+            gate_symbol("cp", 1, 2),
             gate_symbol("swap", 0, 2),
             gate_symbol("ccx", 0, 3),
             gate_symbol("cu", 4, 2),
@@ -520,7 +520,45 @@ impl Lowerer {
 
         let (symbol_id, symbol) = self.try_get_existing_or_insert_err_symbol(&name, ident.span);
 
-        let kind = semantic::ExprKind::Ident(symbol_id);
+        // Design Note: The end goal of this const evaluation is to be able to compile qasm
+        //              annotations as Q# attributes like `@SimulatableIntrinsic()`.
+        //
+        //              QASM3 subroutines and gates can be recursive and capture const symbols
+        //              outside their scope. In Q#, only lambdas can capture symbols, but only
+        //              proper functions and operations can be recursive or have attributes on
+        //              them. To get both, annotations & recursive gates/functions and the
+        //              ability to capture const symbols outside the gate/function scope, we
+        //              decided to compile the gates/functions as proper Q# operations/functions
+        //              and evaluate at lowering-time all references to const symbols outside
+        //              the current gate/function scope.
+
+        // This is true if we are inside any gate or function scope.
+        let is_symbol_inside_gate_or_function_scope =
+            self.symbols.is_scope_rooted_in_gate_or_subroutine();
+
+        // This is true if the symbol is outside the most inner gate or function scope.
+        let is_symbol_outside_most_inner_gate_or_function_scope = self
+            .symbols
+            .is_symbol_outside_most_inner_gate_or_function_scope(symbol_id);
+
+        let is_const_evaluation_necessary = symbol.is_const()
+            && is_symbol_inside_gate_or_function_scope
+            && is_symbol_outside_most_inner_gate_or_function_scope;
+
+        let kind = if is_const_evaluation_necessary {
+            if let Some(val) = symbol.get_const_expr().const_eval(&self.symbols) {
+                semantic::ExprKind::Lit(val)
+            } else {
+                self.push_semantic_error(SemanticErrorKind::ExprMustBeConst(
+                    ident.name.to_string(),
+                    ident.span,
+                ));
+                semantic::ExprKind::Err
+            }
+        } else {
+            semantic::ExprKind::Ident(symbol_id)
+        };
+
         semantic::Expr {
             span: ident.span,
             kind: Box::new(kind),

compiler/qsc_qasm3/src/semantic/symbols.rs

@@ -2,10 +2,9 @@
 // Licensed under the MIT License.
 
 use core::f64;
-use std::rc::Rc;
-
 use qsc_data_structures::{index_map::IndexMap, span::Span};
 use rustc_hash::FxHashMap;
+use std::rc::Rc;
 
 use super::{
     ast::{Expr, ExprKind, LiteralKind},
@@ -137,6 +136,12 @@ impl Symbol {
         }
     }
 
+    /// Returns true if they symbol's value is a const expr.
+    #[must_use]
+    pub fn is_const(&self) -> bool {
+        self.const_expr.is_some()
+    }
+
     /// Returns the value of the symbol.
     #[must_use]
     pub fn get_const_expr(&self) -> Rc<Expr> {
@@ -468,6 +473,22 @@ impl SymbolTable {
         None
     }
 
+    #[must_use]
+    pub fn is_symbol_outside_most_inner_gate_or_function_scope(&self, symbol_id: SymbolId) -> bool {
+        for scope in self.scopes.iter().rev() {
+            if scope.id_to_symbol.contains_key(&symbol_id) {
+                return false;
+            }
+            if matches!(
+                scope.kind,
+                ScopeKind::Gate | ScopeKind::Function | ScopeKind::Global
+            ) {
+                return true;
+            }
+        }
+        unreachable!("when the loop ends we will have visited at least the Global scope");
+    }
+
     #[must_use]
     pub fn is_current_scope_global(&self) -> bool {
         matches!(self.scopes.last(), Some(scope) if scope.kind == ScopeKind::Global)
@@ -481,6 +502,14 @@ impl SymbolTable {
             .any(|scope| scope.kind == ScopeKind::Function)
     }
 
+    #[must_use]
+    pub fn is_scope_rooted_in_gate_or_subroutine(&self) -> bool {
+        self.scopes
+            .iter()
+            .rev()
+            .any(|scope| matches!(scope.kind, ScopeKind::Gate | ScopeKind::Function))
+    }
+
     #[must_use]
     pub fn is_scope_rooted_in_global(&self) -> bool {
         for scope in self.scopes.iter().rev() {

compiler/qsc_qasm3/src/tests/declaration/def.rs

@@ -11,7 +11,7 @@ fn no_parameters_no_return() -> miette::Result<(), Vec<Report>> {
 
     let qsharp = compile_qasm_stmt_to_qsharp(source)?;
     expect![[r#"
-        let empty : () -> Unit = () -> {};
+        function empty() : Unit {}
     "#]]
     .assert_eq(&qsharp);
     Ok(())
@@ -27,9 +27,9 @@ fn single_parameter() -> miette::Result<(), Vec<Report>> {
 
     let qsharp = compile_qasm_stmt_to_qsharp(source)?;
     expect![[r#"
-        let square : (Int) -> Int = (x) -> {
+        function square(x : Int) : Int {
             return x * x;
-        };
+        }
     "#]]
     .assert_eq(&qsharp);
     Ok(())
@@ -45,9 +45,9 @@ fn qubit_parameter() -> miette::Result<(), Vec<Report>> {
 
     let qsharp = compile_qasm_stmt_to_qsharp(source)?;
     expect![[r#"
-        let square : (Qubit) => Int = (q) => {
+        operation square(q : Qubit) : Int {
             return 1;
-        };
+        }
     "#]]
     .assert_eq(&qsharp);
     Ok(())
@@ -63,9 +63,9 @@ fn qubit_array_parameter() -> miette::Result<(), Vec<Report>> {
 
     let qsharp = compile_qasm_stmt_to_qsharp(source)?;
     expect![[r#"
-        let square : (Qubit[]) => Int = (qs) => {
+        operation square(qs : Qubit[]) : Int {
             return 1;
-        };
+        }
     "#]]
     .assert_eq(&qsharp);
     Ok(())