Circuit Editor (#2238)

This PR adds a custom editor view in the VS Code extension for files
with the .qsc extension. The editor makes use of the same library code
that is used to draw circuit diagrams elsewhere in the VS Code
extension. The editor provides basic drag-and-drop editing of circuits
with a simple gate set, including the ability to have controlled gates,
and gates with arguments.
The circuit files are included in Q# projects and can be called into
from Q# as if they were Q# operations. This is done by generating Q#
files for circuit files when compiling.

---------

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

Author: ScottCarda-MS

Cargo.lock

@@ -37,6 +37,10 @@ pub enum ErrorKind {
     #[error("Cycle in dependency graph")]
     /// `DependencyCycle` occurs when there is a cycle in the dependency graph.
     DependencyCycle,
+
+    #[error("{0}")]
+    /// `CircuitParse` variant represents errors that occur while parsing circuit files.
+    CircuitParse(String),
 }
 
 /// Compiles a package from its AST representation.

compiler/qsc/src/compile.rs

@@ -512,7 +512,8 @@ fn custom_intrinsic_mixed_args() {
     "]]
     .assert_eq(&circ.to_string());
 
-    assert_eq!(circ.operations.len(), 1);
+    assert_eq!(circ.component_grid.len(), 1);
+    assert_eq!(circ.component_grid[0].components.len(), 1);
 }
 
 #[test]

compiler/qsc/src/interpret/circuit_tests.rs

@@ -64,7 +64,10 @@ pub mod linter {
 pub use qsc_doc_gen::{display, generate_docs};
 
 pub mod circuit {
-    pub use qsc_circuit::{operations::*, Circuit, Operation};
+    pub use qsc_circuit::{
+        circuit_to_qsharp::circuits_to_qsharp, json_to_circuit::json_to_circuits, operations::*,
+        Circuit, CircuitGroup, Operation, CURRENT_VERSION,
+    };
 }
 
 pub mod parse {

compiler/qsc/src/lib.rs

@@ -2,10 +2,11 @@
 // Licensed under the MIT License.
 
 use crate::{
-    compile::{self, ErrorKind},
+    compile::{self, Error, ErrorKind},
     hir::PackageId,
     PackageStore, TargetCapabilityFlags,
 };
+use qsc_circuit::circuit_to_qsharp::circuits_to_qsharp;
 use qsc_data_structures::language_features::LanguageFeatures;
 use qsc_frontend::compile::SourceMap;
 use qsc_passes::PackageType;
@@ -36,6 +37,44 @@ impl BuildableProgram {
     }
 }
 
+/// Converts circuit files to Q# source code.
+fn convert_circuit_sources(
+    sources: Vec<(Arc<str>, Arc<str>)>,
+    errors: &mut Vec<Error>,
+) -> Vec<(Arc<str>, Arc<str>)> {
+    let mut processed_sources: Vec<(Arc<str>, Arc<str>)> = Vec::new();
+
+    for (name, content) in sources {
+        let name_path = std::path::Path::new(name.as_ref());
+
+        // Check if the file extension is "qsc"
+        if name_path.extension().and_then(|ext| ext.to_str()) == Some("qsc") {
+            let file_stem = name_path
+                .file_stem()
+                .and_then(|stem| stem.to_str())
+                .unwrap_or(name.as_ref());
+
+            // Convert circuit files to Q# source code
+            match circuits_to_qsharp(file_stem, content.as_ref()) {
+                Ok(transformed_content) => {
+                    processed_sources.push((name, Arc::from(transformed_content)));
+                }
+                Err(error_message) => {
+                    errors.push(Error::from_map(
+                        &SourceMap::default(),
+                        ErrorKind::CircuitParse(error_message),
+                    ));
+                }
+            }
+        } else {
+            // Leave other files unchanged
+            processed_sources.push((name, content));
+        }
+    }
+
+    processed_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(
@@ -54,16 +93,16 @@ pub fn prepare_package_store(
     } else {
         // If there was a cycle in the dependencies, we treat the compilation as if
         // there were no dependencies, and report the error upwards
-        dependency_errors.push(qsc_frontend::error::WithSource::from_map(
+        dependency_errors.push(Error::from_map(
             &SourceMap::default(),
             ErrorKind::DependencyCycle,
         ));
         vec![]
     };
 
     for (package_name, package_to_compile) in ordered_packages {
-        let sources: Vec<(Arc<str>, Arc<str>)> =
-            package_to_compile.sources.into_iter().collect::<Vec<_>>();
+        let sources = convert_circuit_sources(package_to_compile.sources, &mut dependency_errors);
+
         let source_map = SourceMap::new(sources, None);
         let dependencies = package_to_compile
             .dependencies
@@ -97,6 +136,16 @@ pub fn prepare_package_store(
         canonical_package_identifier_to_package_id_mapping.insert(package_name, package_id);
     }
 
+    // Convert circuit files in user code to generated Q#
+    let converted_user_code_sources =
+        convert_circuit_sources(user_code.sources, &mut dependency_errors);
+    let user_code = qsc_project::PackageInfo {
+        sources: converted_user_code_sources,
+        language_features: user_code.language_features,
+        dependencies: user_code.dependencies,
+        package_type: user_code.package_type,
+    };
+
     let user_code_dependencies = user_code
         .dependencies
         .iter()

compiler/qsc/src/packages.rs

@@ -19,6 +19,7 @@ qsc_data_structures = { path = "../qsc_data_structures" }
 qsc_frontend = { path = "../qsc_frontend" }
 qsc_fir = { path = "../qsc_fir" }
 qsc_hir = { path = "../qsc_hir" }
+regex-lite = { workspace = true }
 rustc-hash = { workspace = true }
 serde = { workspace = true, features = ["derive"] }
 serde_json = { workspace = true }
@@ -29,5 +30,8 @@ expect-test = { workspace = true }
 indoc = { workspace = true }
 qsc_passes = { path = "../qsc_passes" }
 
+[lints]
+workspace = true
+
 [lib]
 doctest = false