add HIR pass verifying @NoiseIntrinsic() is an intrinsic

Author: orpuente-MS

source/compiler/qsc_frontend/src/lower/tests.rs

@@ -2241,7 +2241,7 @@ fn test_noise_intrinsic_attr_on_function_issues_error() {
         indoc! {r#"
             namespace Test {
                 @NoiseIntrinsic()
-                function Foo(q: Qubit) : Result {
+                function Foo(q: Qubit) : Unit {
                     body intrinsic;
                 }
             }

source/compiler/qsc_passes/src/lib.rs

@@ -13,6 +13,7 @@ mod invert_block;
 mod logic_sep;
 mod loop_unification;
 mod measurement;
+mod noise_intrinsic;
 mod replace_qubit_allocation;
 mod reset;
 mod spec_gen;
@@ -53,6 +54,7 @@ pub enum Error {
     ConjInvert(conjugate_invert::Error),
     EntryPoint(entry_point::Error),
     Measurement(measurement::Error),
+    NoiseIntrinsic(noise_intrinsic::Error),
     Reset(reset::Error),
     SpecGen(spec_gen::Error),
     TestAttribute(test_attribute::TestAttributeError),
@@ -118,6 +120,8 @@ impl PassContext {
 
         let measurement_decl_errors = measurement::validate_measurement_declarations(package);
         let reset_decl_errors = reset::validate_reset_declarations(package);
+        let noise_intrinsic_decl_errors =
+            noise_intrinsic::validate_noise_intrinsic_declarations(package);
 
         let entry_point_errors = generate_entry_expr(package, assigner, package_type);
         Validator::default().visit_package(package);
@@ -140,6 +144,11 @@ impl PassContext {
             .chain(entry_point_errors)
             .chain(measurement_decl_errors.into_iter().map(Error::Measurement))
             .chain(reset_decl_errors.into_iter().map(Error::Reset))
+            .chain(
+                noise_intrinsic_decl_errors
+                    .into_iter()
+                    .map(Error::NoiseIntrinsic),
+            )
             .chain(test_attribute_errors.into_iter().map(Error::TestAttribute))
             .collect()
     }

source/compiler/qsc_passes/src/noise_intrinsic.rs

@@ -0,0 +1,75 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#[cfg(test)]
+mod tests;
+
+use miette::Diagnostic;
+use qsc_data_structures::span::Span;
+use qsc_hir::{
+    hir::{Attr, CallableDecl, Item, ItemKind, Package, SpecBody, SpecGen},
+    ty::Ty,
+    visit::Visitor,
+};
+use thiserror::Error;
+
+#[derive(Clone, Debug, Diagnostic, Error)]
+pub enum Error {
+    #[error("a callable with the @NoiseIntrinsic() attribute should have output of type Unit")]
+    #[diagnostic(code("Qsc.NoiseIntrinsic.NonResultOutput"))]
+    NonUnitOutput(#[label] Span),
+
+    #[error("a callable with the @NoiseIntrinsic() attribute should be an intrinsic")]
+    #[diagnostic(code("Qsc.NoiseIntrinsic.NotIntrinsic"))]
+    NotIntrinsic(#[label] Span),
+}
+
+/// For each noise intrinsic declaration check that:
+///  1. It only outputs Unit.
+///  2. It is an intrinsic.
+pub(super) fn validate_noise_intrinsic_declarations(package: &Package) -> Vec<Error> {
+    let mut validator = NoiseIntrinsicValidator { errors: Vec::new() };
+    validator.visit_package(package);
+    validator.errors
+}
+
+fn validate_noise_intrinsic_declaration(
+    decl: &CallableDecl,
+    attrs: &[Attr],
+    errors: &mut Vec<Error>,
+) {
+    // 1. Check that the declaration only outputs Unit.
+    if decl.output != Ty::UNIT {
+        errors.push(Error::NonUnitOutput(decl.span));
+    }
+
+    // 2. Check that the declaration is an intrinsic.
+    if !decl_is_intrinsic(decl, attrs) {
+        errors.push(Error::NotIntrinsic(decl.name.span));
+    }
+}
+
+/// Returns `true` if a declaration is an intrinsic. A declaration is
+/// an intrinsic if it has `body intrinsic;` in its body or if it has
+/// the `@SimulatableIntrinsic()` attribute.
+fn decl_is_intrinsic(decl: &CallableDecl, attrs: &[Attr]) -> bool {
+    matches!(decl.body.body, SpecBody::Gen(SpecGen::Intrinsic))
+        || attrs
+            .iter()
+            .any(|attr| matches!(attr, Attr::SimulatableIntrinsic))
+}
+
+/// A helper structure to find and validate noise intrinsic callables in a Package.
+struct NoiseIntrinsicValidator {
+    errors: Vec<Error>,
+}
+
+impl<'a> Visitor<'a> for NoiseIntrinsicValidator {
+    fn visit_item(&mut self, item: &'a Item) {
+        if let ItemKind::Callable(callable) = &item.kind
+            && item.attrs.contains(&Attr::NoiseIntrinsic)
+        {
+            validate_noise_intrinsic_declaration(callable, &item.attrs, &mut self.errors);
+        }
+    }
+}

source/compiler/qsc_passes/src/noise_intrinsic/tests.rs

@@ -0,0 +1,72 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+use crate::noise_intrinsic::validate_noise_intrinsic_declarations;
+use expect_test::{Expect, expect};
+use indoc::indoc;
+use qsc_data_structures::{
+    language_features::LanguageFeatures, source::SourceMap, target::TargetCapabilityFlags,
+};
+use qsc_frontend::compile::{self, PackageStore, compile};
+
+fn check(file: &str, expect: &Expect) {
+    let sources = SourceMap::new([("test".into(), file.into())], Some("".into()));
+    let unit = compile(
+        &PackageStore::new(compile::core()),
+        &[],
+        sources,
+        TargetCapabilityFlags::all(),
+        LanguageFeatures::default(),
+    );
+
+    let errors = validate_noise_intrinsic_declarations(&unit.package);
+    expect.assert_debug_eq(&errors);
+}
+
+#[test]
+fn test_noise_intrinsic_attr_on_non_intrinsic_issues_error() {
+    check(
+        indoc! {r#"
+        namespace Test {
+            @NoiseIntrinsic()
+            operation Foo(q: Qubit) : Unit {
+                
+            }
+        }
+    "#},
+        &expect![[r#"
+            [
+                NotIntrinsic(
+                    Span {
+                        lo: 54,
+                        hi: 57,
+                    },
+                ),
+            ]
+        "#]],
+    );
+}
+
+#[test]
+fn test_noise_intrinsic_with_non_unit_return_issues_error() {
+    check(
+        indoc! {r#"
+        namespace Test {
+            @NoiseIntrinsic()
+            operation Foo(q: Qubit) : Int {
+                body intrinsic;
+            }
+        }
+    "#},
+        &expect![[r#"
+            [
+                NonUnitOutput(
+                    Span {
+                        lo: 44,
+                        hi: 105,
+                    },
+                ),
+            ]
+        "#]],
+    );
+}