Circuit Editor

compiler/qsc/src/compile.rs

@@ -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/interpret/circuit_tests.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/lib.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/packages.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_circuit/Cargo.toml

@@ -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