Remove Elided Pattern in HIR (microsoft#379)

Author: ScottCarda-MS

compiler/qsc_eval/src/lib.rs

@@ -20,13 +20,13 @@ use qir_backend::__quantum__rt__initialize;
 use qsc_data_structures::span::Span;
 use qsc_hir::hir::{
     self, BinOp, Block, CallableDecl, Expr, ExprKind, Field, Functor, Lit, LocalItemId, Mutability,
-    NodeId, PackageId, Pat, PatKind, PrimField, Res, Spec, SpecBody, SpecGen, Stmt, StmtKind,
+    NodeId, PackageId, Pat, PatKind, PrimField, Res, SpecBody, SpecGen, Stmt, StmtKind,
     StringComponent, TernOp, UnOp,
 };
 use std::{
     collections::{hash_map::Entry, HashMap},
     convert::AsRef,
-    fmt::Write,
+    fmt::{self, Display, Formatter, Write},
     iter,
     ops::Neg,
     ptr::null_mut,
@@ -56,7 +56,7 @@ pub enum Error {
     IntTooLarge(i64, #[label("this value is too large")] Span),
 
     #[error("missing specialization: {0}")]
-    MissingSpec(Spec, #[label("callable has no {0} specialization")] Span),
+    MissingSpec(String, #[label("callable has no {0} specialization")] Span),
 
     #[error("index out of range: {0}")]
     OutOfRange(i64, #[label("out of range")] Span),
@@ -86,6 +86,29 @@ pub enum Error {
     UserFail(String, #[label("explicit fail")] Span),
 }
 
+/// A specialization that may be implemented for an operation.
+enum Spec {
+    /// The default specialization.
+    Body,
+    /// The adjoint specialization.
+    Adj,
+    /// The controlled specialization.
+    Ctl,
+    /// The controlled adjoint specialization.
+    CtlAdj,
+}
+
+impl Display for Spec {
+    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+        match self {
+            Spec::Body => f.write_str("body"),
+            Spec::Adj => f.write_str("adjoint"),
+            Spec::Ctl => f.write_str("controlled"),
+            Spec::CtlAdj => f.write_str("controlled adjoint"),
+        }
+    }
+}
+
 /// Evaluates the given statement with the given context.
 /// # Errors
 /// Returns the first error encountered during execution.
@@ -780,7 +803,7 @@ impl<'a, G: GlobalLookup<'a>> State<'a, G> {
             Spec::Ctl => callee.ctl.as_ref(),
             Spec::CtlAdj => callee.ctl_adj.as_ref(),
         }
-        .ok_or(Error::MissingSpec(spec, callee_span))?
+        .ok_or(Error::MissingSpec(spec.to_string(), callee_span))?
         .body;
         match block_body {
             SpecBody::Impl(input, body_block) => {
@@ -794,7 +817,7 @@ impl<'a, G: GlobalLookup<'a>> State<'a, G> {
                 self.push_val(val);
                 Ok(())
             }
-            SpecBody::Gen(_) => Err(Error::MissingSpec(spec, callee_span)),
+            SpecBody::Gen(_) => Err(Error::MissingSpec(spec.to_string(), callee_span)),
         }
     }
 
@@ -990,7 +1013,6 @@ fn bind_value(env: &mut Env, pat: &Pat, val: Value, mutability: Mutability) {
             };
         }
         PatKind::Discard => {}
-        PatKind::Elided => panic!("elision used in binding"),
         PatKind::Tuple(tup) => {
             let val_tup = val.unwrap_tuple();
             for (pat, val) in tup.iter().zip(val_tup.iter()) {
@@ -1038,17 +1060,12 @@ fn update_binding(env: &mut Env, lhs: &Expr, rhs: Value) -> Result<(), Error> {
 fn bind_args_for_spec(
     env: &mut Env,
     decl_pat: &Pat,
-    spec_pat: &Pat,
+    spec_pat: &Option<Pat>,
     args_val: Value,
     ctl_count: u8,
 ) {
-    match &spec_pat.kind {
-        PatKind::Bind(_) | PatKind::Discard => {
-            panic!("spec pattern should be elided or elided tuple, found bind/discard")
-        }
-        PatKind::Elided => bind_value(env, decl_pat, args_val, Mutability::Immutable),
-        PatKind::Tuple(pats) => {
-            assert_eq!(pats.len(), 2, "spec pattern tuple should have 2 elements");
+    match spec_pat {
+        Some(spec_pat) => {
             assert!(
                 ctl_count > 0,
                 "spec pattern tuple used without controlled functor"
@@ -1058,20 +1075,21 @@ fn bind_args_for_spec(
             let mut ctls = vec![];
             for _ in 0..ctl_count {
                 let [c, rest] = &*tup.unwrap_tuple() else {
-                    panic!("tuple should be arity 2");
-                };
+                        panic!("tuple should be arity 2");
+                    };
                 ctls.extend_from_slice(&c.clone().unwrap_array());
                 tup = rest.clone();
             }
 
             bind_value(
                 env,
-                &pats[0],
+                spec_pat,
                 Value::Array(ctls.into()),
                 Mutability::Immutable,
             );
             bind_value(env, decl_pat, tup, Mutability::Immutable);
         }
+        None => bind_value(env, decl_pat, args_val, Mutability::Immutable),
     }
 }
 

compiler/qsc_frontend/src/closure.rs

@@ -6,7 +6,7 @@ use qsc_hir::{
     assigner::Assigner,
     hir::{
         Block, CallableDecl, CallableKind, Expr, ExprKind, Ident, Mutability, NodeId, Pat, PatKind,
-        Res, Spec, SpecBody, SpecDecl, Stmt, StmtKind,
+        Res, SpecBody, SpecDecl, Stmt, StmtKind,
     },
     mut_visit::{self, MutVisitor},
     ty::{Arrow, FunctorSetValue, Ty},
@@ -122,8 +122,6 @@ pub(super) fn lift(
     let mut input = closure_input(substituted_vars, lambda.input, span);
     assigner.visit_pat(&mut input);
 
-    let input_ty = input.ty.clone();
-
     let callable = CallableDecl {
         id: assigner.next_node(),
         span,
@@ -140,14 +138,8 @@ pub(super) fn lift(
         body: SpecDecl {
             id: assigner.next_node(),
             span: lambda.body.span,
-            spec: Spec::Body,
             body: SpecBody::Impl(
-                Pat {
-                    id: assigner.next_node(),
-                    span,
-                    ty: input_ty,
-                    kind: PatKind::Elided,
-                },
+                None,
                 Block {
                     id: assigner.next_node(),
                     span: lambda.body.span,

compiler/qsc_frontend/src/compile/tests.rs

@@ -293,8 +293,8 @@ fn replace_node() {
         .kind else { panic!("item should be a callable"); };
     let SpecBody::Impl(_, block) = &callable.body.body else { panic!("callable body have a block") };
     expect![[r#"
-        Block 5 [39-56] [Type Int]:
-            Stmt 6 [49-50]: Expr: Expr 9 [49-50] [Type Int]: Lit: Int(2)"#]]
+        Block 4 [39-56] [Type Int]:
+            Stmt 5 [49-50]: Expr: Expr 8 [49-50] [Type Int]: Lit: Int(2)"#]]
     .assert_eq(&block.to_string());
 }
 
@@ -365,20 +365,19 @@ fn insert_core_call() {
     expect![[r#"
         Package:
             Item 0 [0-43] (Public):
-                Namespace (Ident 6 [10-11] "A"): Item 1
+                Namespace (Ident 5 [10-11] "A"): Item 1
             Item 1 [18-41] (Public):
                 Parent: 0
                 Callable 0 [18-41] (operation):
                     name: Ident 1 [28-31] "Foo"
                     input: Pat 2 [31-33] [Type Unit]: Unit
                     output: Unit
                     functors: empty set
-                    body: SpecDecl 3 [18-41] (Body): Impl:
-                        Pat 4 [18-41] [Type Unit]: Elided
-                        Block 5 [39-41] [Type Unit]:
-                            Stmt 7 [0-0]: Semi: Expr 8 [0-0] [Type Qubit]: Call:
-                                Expr 9 [0-0] [Type (Unit => Qubit)]: Var: Item 4 (Package 0)
-                                Expr 10 [0-0] [Type Unit]: Unit
+                    body: SpecDecl 3 [18-41]: Impl:
+                        Block 4 [39-41] [Type Unit]:
+                            Stmt 6 [0-0]: Semi: Expr 7 [0-0] [Type Qubit]: Call:
+                                Expr 8 [0-0] [Type (Unit => Qubit)]: Var: Item 4 (Package 0)
+                                Expr 9 [0-0] [Type Unit]: Unit
                     adj: <none>
                     ctl: <none>
                     ctl-adj: <none>"#]]

compiler/qsc_frontend/src/lower.rs

@@ -32,6 +32,10 @@ pub(super) enum Error {
     MissingBody(#[label] Span),
     #[error("duplicate specialization")]
     DuplicateSpec(#[label] Span),
+    #[error("invalid use of elided pattern")]
+    InvalidElidedPat(#[label] Span),
+    #[error("invalid pattern for specialization declaration")]
+    InvalidSpecPat(#[label] Span),
 }
 
 #[derive(Clone, Copy)]
@@ -222,16 +226,7 @@ impl With<'_> {
                 let body = hir::SpecDecl {
                     id: self.assigner.next_node(),
                     span: decl.span,
-                    spec: hir::Spec::Body,
-                    body: hir::SpecBody::Impl(
-                        hir::Pat {
-                            id: self.assigner.next_node(),
-                            span: decl.span,
-                            ty: input.ty.clone(),
-                            kind: hir::PatKind::Elided,
-                        },
-                        self.lower_block(block),
-                    ),
+                    body: hir::SpecBody::Impl(None, self.lower_block(block)),
                 };
                 (body, None, None, None)
             }
@@ -241,7 +236,6 @@ impl With<'_> {
                     hir::SpecDecl {
                         id: self.assigner.next_node(),
                         span: decl.span,
-                        spec: hir::Spec::Body,
                         body: hir::SpecBody::Gen(hir::SpecGen::Auto),
                     }
                 });
@@ -294,12 +288,6 @@ impl With<'_> {
         hir::SpecDecl {
             id: self.lower_id(decl.id),
             span: decl.span,
-            spec: match decl.spec {
-                ast::Spec::Body => hir::Spec::Body,
-                ast::Spec::Adj => hir::Spec::Adj,
-                ast::Spec::Ctl => hir::Spec::Ctl,
-                ast::Spec::CtlAdj => hir::Spec::CtlAdj,
-            },
             body: match &decl.body {
                 ast::SpecBody::Gen(gen) => hir::SpecBody::Gen(match gen {
                     ast::SpecGen::Auto => hir::SpecGen::Auto,
@@ -309,12 +297,30 @@ impl With<'_> {
                     ast::SpecGen::Slf => hir::SpecGen::Slf,
                 }),
                 ast::SpecBody::Impl(input, block) => {
-                    hir::SpecBody::Impl(self.lower_pat(input), self.lower_block(block))
+                    hir::SpecBody::Impl(self.lower_spec_decl_pat(input), self.lower_block(block))
                 }
             },
         }
     }
 
+    fn lower_spec_decl_pat(&mut self, pat: &ast::Pat) -> Option<hir::Pat> {
+        if let ast::PatKind::Paren(inner) = &*pat.kind {
+            return self.lower_spec_decl_pat(inner);
+        }
+
+        match &*pat.kind {
+            ast::PatKind::Elided => return None,
+            ast::PatKind::Tuple(items)
+                if items.len() == 2 && *items[1].kind == ast::PatKind::Elided =>
+            {
+                return Some(self.lower_pat(&items[0]));
+            }
+            _ => self.lowerer.errors.push(Error::InvalidSpecPat(pat.span)),
+        };
+
+        None
+    }
+
     fn lower_block(&mut self, block: &ast::Block) -> hir::Block {
         hir::Block {
             id: self.lower_id(block.id),
@@ -621,7 +627,10 @@ impl With<'_> {
                 hir::PatKind::Bind(name)
             }
             ast::PatKind::Discard(_) => hir::PatKind::Discard,
-            ast::PatKind::Elided => hir::PatKind::Elided,
+            ast::PatKind::Elided => {
+                self.lowerer.errors.push(Error::InvalidElidedPat(pat.span));
+                hir::PatKind::Discard
+            }
             ast::PatKind::Paren(_) => unreachable!("parentheses should be removed earlier"),
             ast::PatKind::Tuple(items) => {
                 hir::PatKind::Tuple(items.iter().map(|i| self.lower_pat(i)).collect())