Setting up initial language service configuration. (#2355)

Co-authored-by: Mine Starks <[email protected]>

Author: idavis

Cargo.lock

@@ -18,7 +18,7 @@ use qsc_frontend::{
 use qsc_hir::hir::Package;
 use qsc_partial_eval::ProgramEntry;
 use qsc_passes::PackageType;
-use qsc_project::{FileSystem, StdFs};
+use qsc_project::{FileSystem, ProjectType, StdFs};
 use std::sync::Arc;
 use std::{
     concat, fs,
@@ -300,8 +300,11 @@ fn load_project(
     }
 
     // This builds all the dependencies
+    let ProjectType::QSharp(package_graph_sources) = project.project_type else {
+        panic!("project should be a Q# project");
+    };
     let buildable_program =
-        BuildableProgram::new(TargetCapabilityFlags::all(), project.package_graph_sources);
+        BuildableProgram::new(TargetCapabilityFlags::all(), package_graph_sources);
 
     if !buildable_program.dependency_errors.is_empty() {
         for e in buildable_program.dependency_errors {

compiler/qsc/src/bin/qsc.rs

@@ -21,7 +21,7 @@ use qsc_eval::{
 };
 use qsc_frontend::compile::{SourceContents, SourceMap, SourceName};
 use qsc_passes::PackageType;
-use qsc_project::{FileSystem, StdFs};
+use qsc_project::{FileSystem, ProjectType, StdFs};
 use std::{
     fs,
     io::{self, prelude::BufRead, Write},
@@ -299,8 +299,11 @@ fn load_project(
     }
 
     // This builds all the dependencies
+    let ProjectType::QSharp(package_graph_sources) = project.project_type else {
+        panic!("project should be a Q# project");
+    };
     let buildable_program =
-        BuildableProgram::new(TargetCapabilityFlags::all(), project.package_graph_sources);
+        BuildableProgram::new(TargetCapabilityFlags::all(), package_graph_sources);
 
     if !buildable_program.dependency_errors.is_empty() {
         for e in buildable_program.dependency_errors {

compiler/qsc/src/bin/qsi.rs

@@ -33,7 +33,7 @@ pub mod ast {
 pub mod project {
     pub use qsc_project::{
         DirEntry, EntryType, Error, FileSystem, Manifest, ManifestDescriptor, PackageCache,
-        PackageGraphSources,
+        PackageGraphSources, ProjectType,
     };
 }
 

compiler/qsc/src/lib.rs

@@ -4,53 +4,55 @@ use crate::{compile, LanguageFeatures, TargetCapabilityFlags};
 use expect_test::expect;
 use qsc_frontend::compile::{CompileUnit, SourceMap};
 use qsc_passes::PackageType;
-use qsc_project::{PackageInfo, Project};
+use qsc_project::{PackageInfo, Project, ProjectType};
 use rustc_hash::FxHashMap;
 use std::sync::Arc;
 
 fn mock_program() -> Project {
-    Project {
-        // Mock data for the ProgramConfig
-        package_graph_sources: qsc_project::PackageGraphSources {
-            root: qsc_project::PackageInfo {
+    // Mock data for the ProgramConfig
+    let package_graph_sources = qsc_project::PackageGraphSources {
+        root: qsc_project::PackageInfo {
+            sources: vec![(
+                Arc::from("test"),
+                Arc::from("@EntryPoint() operation Main() : Unit {}"),
+            )],
+            language_features: LanguageFeatures::default(),
+            dependencies: FxHashMap::from_iter(vec![(
+                Arc::from("SomeLibraryAlias"),
+                Arc::from("SomeLibraryKey"),
+            )]),
+            package_type: Some(qsc_project::PackageType::Exe),
+        },
+        packages: FxHashMap::from_iter(vec![(
+            Arc::from("SomeLibraryKey"),
+            PackageInfo {
                 sources: vec![(
-                    Arc::from("test"),
-                    Arc::from("@EntryPoint() operation Main() : Unit {}"),
+                    Arc::from("librarymain"),
+                    Arc::from("operation LibraryMain() : Unit {} export LibraryMain;"),
                 )],
                 language_features: LanguageFeatures::default(),
-                dependencies: FxHashMap::from_iter(vec![(
-                    Arc::from("SomeLibraryAlias"),
-                    Arc::from("SomeLibraryKey"),
-                )]),
-                package_type: Some(qsc_project::PackageType::Exe),
+                dependencies: FxHashMap::default(),
+                package_type: Some(qsc_project::PackageType::Lib),
             },
-            packages: FxHashMap::from_iter(vec![(
-                Arc::from("SomeLibraryKey"),
-                PackageInfo {
-                    sources: vec![(
-                        Arc::from("librarymain"),
-                        Arc::from("operation LibraryMain() : Unit {} export LibraryMain;"),
-                    )],
-                    language_features: LanguageFeatures::default(),
-                    dependencies: FxHashMap::default(),
-                    package_type: Some(qsc_project::PackageType::Lib),
-                },
-            )]),
-        },
+        )]),
+    };
+    Project {
         lints: vec![],
         errors: vec![],
         path: "project/qsharp.json".into(),
         name: "project".into(),
+        project_type: qsc_project::ProjectType::QSharp(package_graph_sources),
     }
 }
 
 #[test]
 fn test_prepare_package_store() {
     let program = mock_program();
-    let buildable_program = super::prepare_package_store(
-        TargetCapabilityFlags::default(),
-        program.package_graph_sources,
-    );
+    let ProjectType::QSharp(package_graph_sources) = program.project_type else {
+        panic!("project should be a Q# project");
+    };
+    let buildable_program =
+        super::prepare_package_store(TargetCapabilityFlags::default(), package_graph_sources);
 
     expect![[r"
             []
@@ -118,17 +120,17 @@ fn test_prepare_package_store() {
 
 #[test]
 fn missing_dependency_doesnt_force_failure() {
-    let mut program = mock_program();
-    program
-        .package_graph_sources
+    let program = mock_program();
+    let ProjectType::QSharp(mut package_graph_sources) = program.project_type else {
+        panic!("project should be a Q# project");
+    };
+    package_graph_sources
         .root
         .dependencies
         .insert("NonExistent".into(), "nonexistent-dep-key".into());
 
-    let buildable_program = super::prepare_package_store(
-        TargetCapabilityFlags::default(),
-        program.package_graph_sources,
-    );
+    let buildable_program =
+        super::prepare_package_store(TargetCapabilityFlags::default(), package_graph_sources);
 
     expect![[r"
             []
@@ -194,21 +196,21 @@ fn missing_dependency_doesnt_force_failure() {
 #[allow(clippy::too_many_lines)]
 #[test]
 fn dependency_error() {
-    let mut program = mock_program();
+    let program = mock_program();
     // Inject a syntax error into one of the dependencies
-    program
-        .package_graph_sources
+    let ProjectType::QSharp(mut package_graph_sources) = program.project_type else {
+        panic!("project should be a Q# project");
+    };
+    package_graph_sources
         .packages
         .values_mut()
         .next()
         .expect("expected at least one dependency in the mock program")
         .sources[0]
         .1 = "broken_syntax".into();
 
-    let buildable_program = super::prepare_package_store(
-        TargetCapabilityFlags::default(),
-        program.package_graph_sources,
-    );
+    let buildable_program =
+        super::prepare_package_store(TargetCapabilityFlags::default(), package_graph_sources);
 
     expect![[r#"
         [

compiler/qsc/src/packages/tests.rs

@@ -1,8 +1,13 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
-use std::path::Path;
+use std::sync::Arc;
 
+use qsc_data_structures::target::TargetCapabilityFlags;
+use qsc_frontend::compile::PackageStore;
+use qsc_frontend::error::WithSource;
+use qsc_hir::hir::PackageId;
+use qsc_passes::PackageType;
 use qsc_qasm::io::SourceResolver;
 pub use qsc_qasm::{
     CompilerConfig, OperationSignature, OutputSemantics, ProgramType, QasmCompileUnit,
@@ -24,17 +29,81 @@ pub mod completion {
 pub use qsc_qasm::compile_to_qsharp_ast_with_config;
 pub use qsc_qasm::package_store_with_qasm;
 
+pub struct CompileRawQasmResult(
+    pub PackageStore,
+    pub PackageId,
+    pub Vec<(PackageId, Option<std::sync::Arc<str>>)>,
+    pub Option<OperationSignature>,
+    pub Vec<crate::compile::Error>,
+);
+
 #[must_use]
-pub fn parse_raw_qasm_as_fragments<S, P, R>(
+pub fn compile_raw_qasm<R: SourceResolver, S: Into<Arc<str>>>(
     source: S,
-    path: P,
+    path: S,
     resolver: Option<&mut R>,
-) -> QasmCompileUnit
-where
-    S: AsRef<str>,
-    P: AsRef<Path>,
-    R: SourceResolver,
-{
+    package_type: PackageType,
+    capabilities: TargetCapabilityFlags,
+) -> CompileRawQasmResult {
+    let config = CompilerConfig::new(
+        QubitSemantics::Qiskit,
+        OutputSemantics::OpenQasm,
+        ProgramType::File,
+        Some("program".into()),
+        None,
+    );
+    compile_with_config(source, path, resolver, config, package_type, capabilities)
+}
+
+#[must_use]
+pub fn compile_with_config<R: SourceResolver, S: Into<Arc<str>>>(
+    source: S,
+    path: S,
+    resolver: Option<&mut R>,
+    config: CompilerConfig,
+    package_type: PackageType,
+    capabilities: TargetCapabilityFlags,
+) -> CompileRawQasmResult {
+    let unit = compile_to_qsharp_ast_with_config(source, path, resolver, config);
+
+    let (source_map, errors, package, sig) = unit.into_tuple();
+
+    let (stdid, qasmid, mut store) = package_store_with_qasm(capabilities);
+    let dependencies = vec![
+        (PackageId::CORE, None),
+        (stdid, None),
+        (qasmid, Some("QasmStd".into())),
+    ];
+
+    let (mut unit, compile_errors) = crate::compile::compile_ast(
+        &store,
+        &dependencies,
+        package,
+        source_map.clone(),
+        package_type,
+        capabilities,
+    );
+    unit.expose();
+    let source_package_id = store.insert(unit);
+
+    let mut compile_errors = compile_errors;
+    for error in errors {
+        let err = WithSource::from_map(
+            &source_map,
+            crate::compile::ErrorKind::OpenQasm(error.into_error()),
+        );
+        compile_errors.push(err);
+    }
+
+    CompileRawQasmResult(store, source_package_id, dependencies, sig, compile_errors)
+}
+
+#[must_use]
+pub fn parse_raw_qasm_as_fragments<R: SourceResolver, S: Into<Arc<str>>>(
+    source: S,
+    path: S,
+    resolver: Option<&mut R>,
+) -> QasmCompileUnit {
     let config = CompilerConfig::new(
         QubitSemantics::Qiskit,
         OutputSemantics::OpenQasm,
@@ -46,22 +115,22 @@ where
 }
 
 #[must_use]
-pub fn parse_raw_qasm_as_operation<S, P, R>(
+pub fn parse_raw_qasm_as_operation<
+    R: SourceResolver,
+    S: Into<Arc<str>>,
+    N: Into<Arc<str>>,
+    P: Into<Arc<str>>,
+>(
     source: S,
-    name: S,
+    name: N,
     path: P,
     resolver: Option<&mut R>,
-) -> QasmCompileUnit
-where
-    S: AsRef<str>,
-    P: AsRef<Path>,
-    R: SourceResolver,
-{
+) -> QasmCompileUnit {
     let config = CompilerConfig::new(
         QubitSemantics::Qiskit,
         OutputSemantics::OpenQasm,
         ProgramType::Operation,
-        Some(name.as_ref().into()),
+        Some(name.into()),
         None,
     );
     compile_to_qsharp_ast_with_config(source, path, resolver, config)

compiler/qsc/src/qasm.rs

@@ -19,6 +19,7 @@ async-trait = { workspace = true }
 qsc_linter = { path = "../qsc_linter" }
 qsc_circuit = { path = "../qsc_circuit" }
 qsc_data_structures = { path = "../qsc_data_structures" }
+qsc_qasm = { path = "../qsc_qasm" }
 rustc-hash = { workspace = true }
 futures = { workspace = true }
 log = { workspace = true }

compiler/qsc_project/Cargo.toml

@@ -13,6 +13,7 @@ mod error;
 mod fs;
 mod js;
 mod manifest;
+pub mod openqasm;
 mod project;
 
 pub use error::StdFsError;
@@ -23,5 +24,6 @@ pub use manifest::{Manifest, ManifestDescriptor, PackageRef, PackageType, MANIFE
 pub use project::FileSystemAsync;
 pub use project::{
     key_for_package_ref, package_ref_from_key, DependencyCycle, DirEntry, EntryType, Error,
-    FileSystem, PackageCache, PackageGraphSources, PackageInfo, Project, GITHUB_SCHEME,
+    FileSystem, PackageCache, PackageGraphSources, PackageInfo, Project, ProjectType,
+    GITHUB_SCHEME,
 };