QIR Profiles Selection via Project Field or EntryPoint argument (#2591)

This removes the workspace setting for the QIR profile and adds a
setting for this for Q# project files instead, i.e. `"targetProfile":
"base"`. Single-file Q# files are supported by adding an argument to the
@entrypoint attribute where a user will specify what profile the file is
meant to compile with, i.e. `@EntryPoint(Adaptive_RI)`, or uses
`Unrestricted` as a default.

Author: ScottCarda-MS

source/compiler/qsc/src/compile.rs

@@ -2,7 +2,9 @@
 // Licensed under the MIT License.
 
 use miette::{Diagnostic, Report};
-use qsc_data_structures::{language_features::LanguageFeatures, target::TargetCapabilityFlags};
+use qsc_data_structures::{
+    language_features::LanguageFeatures, span::Span, target::TargetCapabilityFlags,
+};
 pub use qsc_frontend::compile::Dependencies;
 use qsc_frontend::{
     compile::{CompileUnit, PackageStore, SourceMap},
@@ -45,6 +47,11 @@ pub enum ErrorKind {
     /// `OpenQASM` compilation errors.
     #[diagnostic(transparent)]
     OpenQasm(#[from] crate::qasm::error::Error),
+
+    #[error(
+        "The @EntryPoint attribute with a profile argument is not allowed in a Q# project (with qsharp.json). Please specify the profile in qsharp.json instead."
+    )]
+    EntryPointProfileInProject(#[label] Span),
 }
 
 /// Compiles a package from its AST representation.

source/compiler/qsc/src/interpret.rs

@@ -99,6 +99,9 @@ pub enum Error {
     NoEntryPoint,
     #[error("unsupported runtime capabilities for code generation")]
     #[diagnostic(code("Qsc.Interpret.UnsupportedRuntimeCapabilities"))]
+    #[diagnostic(help(
+        "@EntryPoint attribute argument should be 'Base', 'Adaptive_RI' or 'Adaptive_RIF'"
+    ))]
     UnsupportedRuntimeCapabilities,
     #[error("expression does not evaluate to an operation")]
     #[diagnostic(code("Qsc.Interpret.NotAnOperation"))]

source/compiler/qsc/src/interpret/package_tests.rs

@@ -19,7 +19,7 @@ fn import_and_call_reexport() {
                 indoc! {"
                     import Foo.DependencyA.Foo;
                     function Main() : Unit {
-                        Foo([1, 2]); 
+                        Foo([1, 2]);
                         Foo.DependencyA.MagicFunction();
                     }"}
                 .into(),
@@ -50,6 +50,7 @@ fn import_and_call_reexport() {
         )]
         .into_iter()
         .collect(),
+        has_manifest: true,
     };
 
     // This builds all the dependencies
@@ -129,6 +130,7 @@ fn directly_call_reexport() {
         )]
         .into_iter()
         .collect(),
+        has_manifest: true,
     };
 
     // This builds all the dependencies

source/compiler/qsc/src/lib.rs

@@ -8,7 +8,6 @@ pub mod incremental;
 pub mod interpret;
 pub mod location;
 pub mod packages;
-pub mod target;
 
 pub use qsc_formatter::formatter;
 
@@ -80,4 +79,8 @@ pub mod partial_eval {
     pub use qsc_partial_eval::Error;
 }
 
+pub mod target {
+    pub use qsc_data_structures::target::Profile;
+}
+
 pub mod qasm;

source/compiler/qsc/src/packages.rs

@@ -8,7 +8,7 @@ use crate::{
 };
 use qsc_circuit::circuit_to_qsharp::circuits_to_qsharp;
 use qsc_data_structures::language_features::LanguageFeatures;
-use qsc_frontend::compile::SourceMap;
+use qsc_frontend::compile::{SourceMap, check_for_entry_profile};
 use qsc_passes::PackageType;
 use qsc_project::PackageGraphSources;
 use rustc_hash::FxHashMap;
@@ -24,6 +24,7 @@ pub struct BuildableProgram {
     pub user_code: qsc_project::PackageInfo,
     pub user_code_dependencies: Vec<(PackageId, Option<Arc<str>>)>,
     pub dependency_errors: Vec<compile::Error>,
+    pub capabilities: TargetCapabilityFlags,
 }
 
 impl BuildableProgram {
@@ -78,16 +79,40 @@ fn convert_circuit_sources(
 /// Given a program config, prepare the package store by compiling all dependencies in the correct order and inserting them.
 #[must_use]
 pub fn prepare_package_store(
-    capabilities: TargetCapabilityFlags,
+    mut capabilities: TargetCapabilityFlags,
     package_graph_sources: PackageGraphSources,
 ) -> BuildableProgram {
+    let mut dependency_errors = Vec::new();
+
+    // Convert circuit files in user code to generated Q# before entry profile check
+    let mut sources = package_graph_sources.root.sources.clone();
+    sources = convert_circuit_sources(sources, &mut dependency_errors);
+
+    // Check if the entry profile is set in the source code.
+    let entry_profile = check_for_entry_profile(
+        &SourceMap::new(sources.clone(), None),
+        package_graph_sources.root.language_features,
+    );
+
+    // If the entry profile is set, we need to ensure that the user code is compiled with it.
+    if let Some((profile, span)) = entry_profile {
+        // If this is a project (qsharp.json present), emit error with span
+        if package_graph_sources.has_manifest {
+            dependency_errors.push(Error::from_map(
+                &SourceMap::new(sources, None),
+                ErrorKind::EntryPointProfileInProject(span),
+            ));
+        } else {
+            capabilities = profile.into();
+        }
+    }
+
     let (std_id, mut package_store) = package_store_with_stdlib(capabilities);
 
     let mut canonical_package_identifier_to_package_id_mapping = FxHashMap::default();
 
     let (ordered_packages, user_code) = package_graph_sources.compilation_order();
 
-    let mut dependency_errors = Vec::new();
     let ordered_packages = if let Ok(o) = ordered_packages {
         o
     } else {
@@ -163,5 +188,6 @@ pub fn prepare_package_store(
         dependency_errors,
         user_code,
         user_code_dependencies,
+        capabilities,
     }
 }

source/compiler/qsc/src/packages/tests.rs

@@ -35,13 +35,15 @@ fn mock_program() -> Project {
                 package_type: Some(qsc_project::PackageType::Lib),
             },
         )]),
+        has_manifest: true,
     };
     Project {
         lints: vec![],
         errors: vec![],
         path: "project/qsharp.json".into(),
         name: "project".into(),
         project_type: qsc_project::ProjectType::QSharp(package_graph_sources),
+        target_profile: qsc_data_structures::target::Profile::Unrestricted,
     }
 }
 

source/compiler/qsc/src/target.rs

@@ -38,3 +38,55 @@ impl Default for TargetCapabilityFlags {
         TargetCapabilityFlags::empty()
     }
 }
+
+use std::str::FromStr;
+
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum Profile {
+    Unrestricted,
+    Base,
+    AdaptiveRI,
+    AdaptiveRIF,
+}
+
+impl Profile {
+    #[must_use]
+    pub fn to_str(&self) -> &'static str {
+        match self {
+            Self::Unrestricted => "Unrestricted",
+            Self::Base => "Base",
+            Self::AdaptiveRI => "Adaptive_RI",
+            Self::AdaptiveRIF => "Adaptive_RIF",
+        }
+    }
+}
+
+impl From<Profile> for TargetCapabilityFlags {
+    fn from(value: Profile) -> Self {
+        match value {
+            Profile::Unrestricted => Self::all(),
+            Profile::Base => Self::empty(),
+            Profile::AdaptiveRI => Self::Adaptive | Self::QubitReset | Self::IntegerComputations,
+            Profile::AdaptiveRIF => {
+                Self::Adaptive
+                    | Self::QubitReset
+                    | Self::IntegerComputations
+                    | Self::FloatingPointComputations
+            }
+        }
+    }
+}
+
+impl FromStr for Profile {
+    type Err = ();
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s.to_lowercase().as_str() {
+            "adaptive_ri" => Ok(Self::AdaptiveRI),
+            "adaptive_rif" => Ok(Self::AdaptiveRIF),
+            "base" => Ok(Self::Base),
+            "unrestricted" => Ok(Self::Unrestricted),
+            _ => Err(()),
+        }
+    }
+}

source/compiler/qsc_data_structures/src/target.rs

@@ -26,7 +26,7 @@ use qsc_data_structures::{
     index_map::{self, IndexMap},
     language_features::LanguageFeatures,
     span::Span,
-    target::TargetCapabilityFlags,
+    target::{Profile, TargetCapabilityFlags},
 };
 use qsc_hir::{
     assigner::Assigner as HirAssigner,
@@ -530,6 +530,22 @@ pub fn parse_all(
     (package, errors)
 }
 
+#[must_use]
+pub fn check_for_entry_profile(
+    sources: &SourceMap,
+    language_features: LanguageFeatures,
+) -> Option<(Profile, Span)> {
+    let (ast_package, parse_errors) = parse_all(sources, language_features);
+
+    if !parse_errors.is_empty() {
+        return None;
+    }
+
+    let mut check = preprocess::DetectEntryPointProfile::new();
+    check.visit_package(&ast_package);
+    check.profile
+}
+
 pub(crate) struct ResolveResult {
     pub names: Names,
     pub locals: Locals,

source/compiler/qsc_frontend/src/compile.rs

@@ -8,8 +8,9 @@ use qsc_ast::{
         TopLevelNode, UnOp,
     },
     mut_visit::{MutVisitor, walk_stmt},
+    visit::Visitor,
 };
-use qsc_data_structures::span::Span;
+use qsc_data_structures::{span::Span, target::Profile};
 use qsc_hir::hir;
 use std::rc::Rc;
 
@@ -18,6 +19,34 @@ use super::{SourceMap, TargetCapabilityFlags};
 #[cfg(test)]
 mod tests;
 
+/// Transformation to detect `@EntryPoint` attribute in the AST.
+#[derive(Default)]
+pub struct DetectEntryPointProfile {
+    pub profile: Option<(Profile, Span)>,
+}
+
+impl DetectEntryPointProfile {
+    #[must_use]
+    pub fn new() -> Self {
+        Self { profile: None }
+    }
+}
+
+impl Visitor<'_> for DetectEntryPointProfile {
+    fn visit_attr(&mut self, attr: &Attr) {
+        if hir::Attr::from_str(attr.name.name.as_ref()) == Ok(hir::Attr::EntryPoint) {
+            // Try to parse the argument as a profile name
+            if let ExprKind::Paren(inner) = attr.arg.kind.as_ref() {
+                if let ExprKind::Path(PathKind::Ok(path)) = inner.kind.as_ref() {
+                    if let Ok(profile) = Profile::from_str(path.name.name.as_ref()) {
+                        self.profile = Some((profile, path.span));
+                    }
+                }
+            }
+        }
+    }
+}
+
 #[derive(PartialEq, Hash, Clone, Debug)]
 pub struct TrackedName {
     pub name: Rc<str>,