Use RCA and new QIR code generation

compiler/qsc/src/codegen.rs

@@ -9,7 +9,6 @@ use qsc_data_structures::{language_features::LanguageFeatures, target::TargetCap
 use qsc_frontend::compile::{PackageStore, SourceMap};
 use qsc_partial_eval::ProgramEntry;
 use qsc_passes::{PackageType, PassContext};
-use qsc_rca::Analyzer;
 
 use crate::compile;
 
@@ -59,18 +58,12 @@ pub fn get_qir(
             .into(),
     };
 
-    let compute_properties = if capabilities == TargetCapabilityFlags::empty() {
-        // baseprofchk already handled compliance, run the analyzer to get the compute properties.
-        let analyzer = Analyzer::init(&fir_store);
-        Ok(analyzer.analyze_all())
-    } else {
+    let Ok(compute_properties) =
         PassContext::run_fir_passes_on_fir(&fir_store, fir_package_id, capabilities)
-    };
-
-    let Ok(compute_properties) = compute_properties else {
+    else {
         // This should never happen, as the program should be checked for errors before trying to
         // generate code for it. But just in case, simply report the failure.
-        return Err("Failed to generate QIR. Could not generate compute properties.".to_string());
+        return Err("Failed to generate QIR. Program contains errors.".to_string());
     };
 
     fir_to_qir(&fir_store, capabilities, Some(compute_properties), &entry)

compiler/qsc/src/compile.rs

@@ -43,6 +43,7 @@ pub fn compile_ast(
     sources: SourceMap,
     package_type: PackageType,
     capabilities: TargetCapabilityFlags,
+    language_features: LanguageFeatures,
 ) -> (CompileUnit, Vec<Error>) {
     let unit = qsc_frontend::compile::compile_ast(
         store,
@@ -52,7 +53,7 @@ pub fn compile_ast(
         capabilities,
         vec![],
     );
-    process_compile_unit(store, package_type, capabilities, unit)
+    process_compile_unit(store, package_type, capabilities, unit, language_features)
 }
 
 /// Compiles a package from its source representation.
@@ -72,7 +73,7 @@ pub fn compile(
         capabilities,
         language_features,
     );
-    process_compile_unit(store, package_type, capabilities, unit)
+    process_compile_unit(store, package_type, capabilities, unit, language_features)
 }
 
 #[must_use]
@@ -82,14 +83,17 @@ fn process_compile_unit(
     package_type: PackageType,
     capabilities: TargetCapabilityFlags,
     mut unit: CompileUnit,
+    language_features: LanguageFeatures,
 ) -> (CompileUnit, Vec<Error>) {
     let mut errors = Vec::new();
     for error in unit.errors.drain(..) {
         errors.push(WithSource::from_map(&unit.sources, error.into()));
     }
 
+    let use_baseprofck =
+        capabilities.is_empty() && !language_features.contains(LanguageFeatures::PreviewQirGen);
     if errors.is_empty() {
-        for error in run_default_passes(store.core(), &mut unit, package_type, capabilities) {
+        for error in run_default_passes(store.core(), &mut unit, package_type, use_baseprofck) {
             errors.push(WithSource::from_map(&unit.sources, error.into()));
         }
     }
@@ -126,7 +130,7 @@ pub fn core() -> CompileUnit {
 #[must_use]
 pub fn std(store: &PackageStore, capabilities: TargetCapabilityFlags) -> CompileUnit {
     let mut unit = qsc_frontend::compile::std(store, capabilities);
-    let pass_errors = run_default_passes(store.core(), &mut unit, PackageType::Lib, capabilities);
+    let pass_errors = run_default_passes(store.core(), &mut unit, PackageType::Lib, false);
     if pass_errors.is_empty() {
         unit
     } else {

compiler/qsc/src/incremental.rs

@@ -74,12 +74,13 @@ impl Compiler {
             language_features,
         );
         let store = store.open();
-
+        let use_baseprofck =
+            capabilities.is_empty() && !language_features.contains(LanguageFeatures::PreviewQirGen);
         Ok(Self {
             store,
             source_package_id,
             frontend,
-            passes: PassContext::new(capabilities),
+            passes: PassContext::new(use_baseprofck),
         })
     }
 
@@ -92,12 +93,13 @@ impl Compiler {
         let frontend =
             qsc_frontend::incremental::Compiler::new(&store, [], capabilities, language_features);
         let store = store.open();
-
+        let use_baseprofck =
+            capabilities.is_empty() && !language_features.contains(LanguageFeatures::PreviewQirGen);
         Ok(Self {
             store,
             source_package_id,
             frontend,
-            passes: PassContext::new(capabilities),
+            passes: PassContext::new(use_baseprofck),
         })
     }
 

compiler/qsc_codegen/src/qir_base/tests.rs

@@ -19,13 +19,7 @@ fn check(program: &str, expr: Option<&str>, expect: &Expect) {
     assert!(run_core_passes(&mut core).is_empty());
     let mut store = PackageStore::new(core);
     let mut std = compile::std(&store, TargetCapabilityFlags::empty());
-    assert!(run_default_passes(
-        store.core(),
-        &mut std,
-        PackageType::Lib,
-        TargetCapabilityFlags::empty()
-    )
-    .is_empty());
+    assert!(run_default_passes(store.core(), &mut std, PackageType::Lib, false).is_empty());
     let std = store.insert(std);
 
     let expr_as_arc: Option<Arc<str>> = expr.map(|s| Arc::from(s.to_string()));
@@ -39,13 +33,7 @@ fn check(program: &str, expr: Option<&str>, expect: &Expect) {
         LanguageFeatures::default(),
     );
     assert!(unit.errors.is_empty(), "{:?}", unit.errors);
-    assert!(run_default_passes(
-        store.core(),
-        &mut unit,
-        PackageType::Exe,
-        TargetCapabilityFlags::empty()
-    )
-    .is_empty());
+    assert!(run_default_passes(store.core(), &mut unit, PackageType::Exe, false).is_empty());
     let package = store.insert(unit);
 
     let qir = generate_qir(&store, package);

compiler/qsc_codegen/src/qsharp/test_utils.rs

@@ -34,13 +34,7 @@ pub(crate) fn get_compilation(sources: Option<SourceMap>) -> (PackageId, Package
     assert!(run_core_passes(&mut core).is_empty());
     let mut store = PackageStore::new(core);
     let mut std = compile::std(&store, TargetCapabilityFlags::empty());
-    assert!(run_default_passes(
-        store.core(),
-        &mut std,
-        PackageType::Lib,
-        TargetCapabilityFlags::empty()
-    )
-    .is_empty());
+    assert!(run_default_passes(store.core(), &mut std, PackageType::Lib, false).is_empty());
     let std = store.insert(std);
 
     let mut unit = compile(
@@ -51,13 +45,7 @@ pub(crate) fn get_compilation(sources: Option<SourceMap>) -> (PackageId, Package
         LanguageFeatures::empty(),
     );
     assert!(unit.errors.is_empty(), "{:?}", unit.errors);
-    assert!(run_default_passes(
-        store.core(),
-        &mut unit,
-        PackageType::Lib,
-        TargetCapabilityFlags::all()
-    )
-    .is_empty());
+    assert!(run_default_passes(store.core(), &mut unit, PackageType::Lib, false).is_empty());
     let package_id = store.insert(unit);
     (package_id, store)
 }

compiler/qsc_eval/src/intrinsic/tests.rs

@@ -154,13 +154,7 @@ fn check_intrinsic(file: &str, expr: &str, out: &mut impl Receiver) -> Result<Va
 
     let mut std = compile::std(&store, TargetCapabilityFlags::all());
     assert!(std.errors.is_empty());
-    assert!(run_default_passes(
-        store.core(),
-        &mut std,
-        PackageType::Lib,
-        TargetCapabilityFlags::all()
-    )
-    .is_empty());
+    assert!(run_default_passes(store.core(), &mut std, PackageType::Lib, false).is_empty());
     let std_fir = qsc_lowerer::Lowerer::new().lower_package(&std.package);
     let std_id = store.insert(std);
 
@@ -173,13 +167,7 @@ fn check_intrinsic(file: &str, expr: &str, out: &mut impl Receiver) -> Result<Va
         LanguageFeatures::default(),
     );
     assert!(unit.errors.is_empty());
-    assert!(run_default_passes(
-        store.core(),
-        &mut unit,
-        PackageType::Lib,
-        TargetCapabilityFlags::all()
-    )
-    .is_empty());
+    assert!(run_default_passes(store.core(), &mut unit, PackageType::Lib, false).is_empty());
     let unit_fir = qsc_lowerer::Lowerer::new().lower_package(&unit.package);
     let entry = unit_fir.entry_exec_graph.clone();
 

compiler/qsc_eval/src/tests.rs

@@ -51,13 +51,7 @@ fn check_expr(file: &str, expr: &str, expect: &Expect) {
 
     let mut std = compile::std(&store, TargetCapabilityFlags::all());
     assert!(std.errors.is_empty());
-    assert!(run_default_passes(
-        store.core(),
-        &mut std,
-        PackageType::Lib,
-        TargetCapabilityFlags::all()
-    )
-    .is_empty());
+    assert!(run_default_passes(store.core(), &mut std, PackageType::Lib, false).is_empty());
     let std_fir = fir_lowerer.lower_package(&std.package);
     let std_id = store.insert(std);
 
@@ -70,12 +64,7 @@ fn check_expr(file: &str, expr: &str, expect: &Expect) {
         LanguageFeatures::default(),
     );
     assert!(unit.errors.is_empty(), "{:?}", unit.errors);
-    let pass_errors = run_default_passes(
-        store.core(),
-        &mut unit,
-        PackageType::Lib,
-        TargetCapabilityFlags::all(),
-    );
+    let pass_errors = run_default_passes(store.core(), &mut unit, PackageType::Lib, false);
     assert!(pass_errors.is_empty(), "{pass_errors:?}");
     let unit_fir = fir_lowerer.lower_package(&unit.package);
     let entry = unit_fir.entry_exec_graph.clone();
@@ -117,13 +106,7 @@ fn check_partial_eval_stmt(
 
     let mut std = compile::std(&store, TargetCapabilityFlags::all());
     assert!(std.errors.is_empty());
-    assert!(run_default_passes(
-        store.core(),
-        &mut std,
-        PackageType::Lib,
-        TargetCapabilityFlags::all()
-    )
-    .is_empty());
+    assert!(run_default_passes(store.core(), &mut std, PackageType::Lib, false).is_empty());
     let std_fir = qsc_lowerer::Lowerer::new().lower_package(&std.package);
     let std_id = store.insert(std);
 
@@ -136,12 +119,7 @@ fn check_partial_eval_stmt(
         LanguageFeatures::default(),
     );
     assert!(unit.errors.is_empty(), "{:?}", unit.errors);
-    let pass_errors = run_default_passes(
-        store.core(),
-        &mut unit,
-        PackageType::Lib,
-        TargetCapabilityFlags::all(),
-    );
+    let pass_errors = run_default_passes(store.core(), &mut unit, PackageType::Lib, false);
     assert!(pass_errors.is_empty(), "{pass_errors:?}");
     let unit_fir = qsc_lowerer::Lowerer::new().lower_package(&unit.package);
     fir_expect.assert_eq(&unit_fir.to_string());

compiler/qsc_passes/src/baseprofck/tests.rs

@@ -12,13 +12,13 @@ use crate::baseprofck::check_base_profile_compliance;
 
 fn check(expr: &str, expect: &Expect) {
     let mut store = PackageStore::new(compile::core());
-    let std = store.insert(compile::std(&store, TargetCapabilityFlags::all()));
+    let std = store.insert(compile::std(&store, TargetCapabilityFlags::empty()));
     let sources = SourceMap::new([("test".into(), "".into())], Some(expr.into()));
     let unit = compile(
         &store,
         &[std],
         sources,
-        TargetCapabilityFlags::all(),
+        TargetCapabilityFlags::empty(),
         LanguageFeatures::default(),
     );
     assert!(unit.errors.is_empty(), "{:?}", unit.errors);

compiler/qsc_passes/src/lib.rs

@@ -69,15 +69,15 @@ pub fn lower_hir_to_fir(
 }
 
 pub struct PassContext {
-    capabilities: TargetCapabilityFlags,
+    use_baseprofck: bool,
     borrow_check: borrowck::Checker,
 }
 
 impl PassContext {
     #[must_use]
-    pub fn new(capabilities: TargetCapabilityFlags) -> Self {
+    pub fn new(use_baseprofck: bool) -> Self {
         Self {
-            capabilities,
+            use_baseprofck,
             borrow_check: borrowck::Checker::default(),
         }
     }
@@ -117,7 +117,7 @@ impl PassContext {
         ReplaceQubitAllocation::new(core, assigner).visit_package(package);
         Validator::default().visit_package(package);
 
-        let base_prof_errors = if self.capabilities == TargetCapabilityFlags::empty() {
+        let base_prof_errors = if self.use_baseprofck {
             baseprofck::check_base_profile_compliance(package)
         } else {
             Vec::new()
@@ -148,9 +148,9 @@ pub fn run_default_passes(
     core: &Table,
     unit: &mut CompileUnit,
     package_type: PackageType,
-    capabilities: TargetCapabilityFlags,
+    use_baseprofck: bool,
 ) -> Vec<Error> {
-    PassContext::new(capabilities).run_default_passes(
+    PassContext::new(use_baseprofck).run_default_passes(
         &mut unit.package,
         &mut unit.assigner,
         core,

language_service/src/compilation.rs

@@ -77,13 +77,15 @@ impl Compilation {
             .get(package_id)
             .expect("expected to find user package");
 
-        run_fir_passes(
-            &mut errors,
-            target_profile,
-            &package_store,
-            package_id,
-            unit,
-        );
+        if language_features.contains(LanguageFeatures::PreviewQirGen) {
+            run_fir_passes(
+                &mut errors,
+                target_profile,
+                &package_store,
+                package_id,
+                unit,
+            );
+        }
 
         run_linter_passes(lints_config, &mut errors, unit);
 
@@ -133,13 +135,15 @@ impl Compilation {
             .get(package_id)
             .expect("expected to find user package");
 
-        run_fir_passes(
-            &mut errors,
-            target_profile,
-            &package_store,
-            package_id,
-            unit,
-        );
+        if language_features.contains(LanguageFeatures::PreviewQirGen) {
+            run_fir_passes(
+                &mut errors,
+                target_profile,
+                &package_store,
+                package_id,
+                unit,
+            );
+        }
 
         run_linter_passes(lints_config, &mut errors, unit);
 
@@ -257,11 +261,6 @@ fn run_fir_passes(
         return;
     }
 
-    if target_profile == Profile::Base {
-        // baseprofchk will handle the case where the target profile is Base
-        return;
-    }
-
     if target_profile == Profile::Unrestricted {
         // no point in running passes on unrestricted profile
         return;

language_service/src/protocol.rs

@@ -10,6 +10,7 @@ use qsc_project::Manifest;
 pub struct WorkspaceConfigurationUpdate {
     pub target_profile: Option<Profile>,
     pub package_type: Option<PackageType>,
+    pub language_features: Option<LanguageFeatures>,
 }
 
 #[derive(Debug)]