Unify compilation and error propagation. (#2247)

Author: idavis

compiler/qsc_qasm3/src/compile.rs

@@ -68,11 +68,6 @@ pub fn qasm_to_program(
     source_map: SourceMap,
     config: CompilerConfig,
 ) -> QasmCompileUnit {
-    assert!(!source.has_errors(), "Source has errors");
-    assert!(
-        source.parse_result().have_parse(),
-        "Source has not been successfully parsed"
-    );
     let compiler = QasmCompiler {
         source,
         source_map,

compiler/qsc_qasm3/src/compile/tests.rs

@@ -18,7 +18,7 @@ fn programs_with_includes_with_includes_can_be_compiled() -> miette::Result<(),
         ("source2.qasm".into(), source2.into()),
     ];
 
-    let unit = compile_all_fragments("source0.qasm", all_sources)?;
+    let unit = compile_all_fragments("source0.qasm", all_sources).map_err(|e| vec![e])?;
     print_compilation_errors(&unit);
     assert!(!unit.has_errors());
     Ok(())
@@ -39,7 +39,7 @@ fn including_stdgates_multiple_times_causes_symbol_redifintion_errors(
         ("source2.qasm".into(), source2.into()),
     ];
 
-    let unit = compile_all_fragments("source0.qasm", all_sources)?;
+    let unit = compile_all_fragments("source0.qasm", all_sources).map_err(|e| vec![e])?;
     assert!(unit.has_errors());
     for error in unit.errors() {
         assert!(error.to_string().contains("Redefined symbol: "));

compiler/qsc_qasm3/src/compiler.rs

@@ -1,7 +1,7 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
-use std::rc::Rc;
+use std::{path::Path, rc::Rc, sync::Arc};
 
 use num_bigint::BigInt;
 use qsc_data_structures::span::Span;
@@ -19,6 +19,7 @@ use crate::{
         build_top_level_ns_with_item, build_tuple_expr, build_unary_op_expr, build_while_stmt,
         build_wrapped_block_expr, map_qsharp_type_to_ast_ty, wrap_expr_in_parens,
     },
+    io::{InMemorySourceResolver, SourceResolver},
     parser::ast::{list_from_iter, List},
     runtime::{get_runtime_function_decls, RuntimeFunctions},
     semantic::{
@@ -36,6 +37,62 @@ use crate::{
 use crate::semantic::ast as semast;
 use qsc_ast::ast::{self as qsast, NodeId, Package};
 
+pub fn compile_anon_with_config<S>(
+    source: S,
+    config: CompilerConfig,
+) -> miette::Result<QasmCompileUnit>
+where
+    S: AsRef<str>,
+{
+    let path = std::path::PathBuf::from("Test.qasm");
+    let sources = [(
+        Arc::from(path.display().to_string().as_str()),
+        Arc::from(source.as_ref()),
+    )];
+    let resolver = InMemorySourceResolver::from_iter(sources);
+    let source = resolver.resolve(&path)?.1;
+    compile_with_config(source, &path, &resolver, config)
+}
+
+pub fn compile_all_with_config<P>(
+    path: P,
+    sources: impl IntoIterator<Item = (Arc<str>, Arc<str>)>,
+    config: CompilerConfig,
+) -> miette::Result<QasmCompileUnit>
+where
+    P: AsRef<Path>,
+{
+    let resolver = InMemorySourceResolver::from_iter(sources);
+    let source = resolver.resolve(path.as_ref())?.1;
+    compile_with_config(source, path, &resolver, config)
+}
+
+pub fn compile_with_config<S, P, R>(
+    source: S,
+    path: P,
+    resolver: &R,
+    config: CompilerConfig,
+) -> miette::Result<QasmCompileUnit>
+where
+    S: AsRef<str>,
+    P: AsRef<Path>,
+    R: SourceResolver,
+{
+    let res = crate::semantic::parse_source(source, path, resolver)?;
+    let program = res.program;
+
+    let compiler = crate::compiler::QasmCompiler {
+        source_map: res.source_map,
+        config,
+        stmts: vec![],
+        runtime: RuntimeFunctions::empty(),
+        symbols: res.symbols,
+        errors: res.errors,
+    };
+
+    Ok(compiler.compile(&program))
+}
+
 pub struct QasmCompiler {
     /// The source map of QASM sources for error reporting.
     pub source_map: SourceMap,

compiler/qsc_qasm3/src/parse.rs

@@ -91,9 +91,7 @@ fn create_source_map(source: &QasmSource) -> SourceMap {
     for include in source.includes() {
         collect_source_files(include, &mut files);
     }
-    // Map the main source file to the entry point expression
-    // This may be incorrect, but it's the best we can do for now.
-    SourceMap::new(files, Some(Arc::from(source.source())))
+    SourceMap::new(files, None)
 }
 
 /// Recursively collect all source files from the includes

compiler/qsc_qasm3/src/parser/completion/word_kinds.rs

@@ -125,7 +125,6 @@ impl WordKinds {
         self.iter().filter_map(|p| match p {
             WordKinds::PathExpr => Some(NameKind::Path(PathKind::Expr)),
             WordKinds::PathSegment => Some(NameKind::PathSegment),
-            WordKinds::PrimitiveClass => Some(NameKind::PrimitiveClass),
             _ => None,
         })
     }
@@ -163,8 +162,6 @@ pub enum NameKind {
     /// A path segment that follows a `.`
     /// A more specific name kind can only be inferred from a recovered AST.
     PathSegment,
-    /// A primitive class, like Eq, Exp, or Add.
-    PrimitiveClass,
 }
 
 /// A path (see: [`Predictions`])

compiler/qsc_qasm3/src/semantic.rs

@@ -7,7 +7,6 @@ use crate::parser::QasmSource;
 use lowerer::Lowerer;
 use qsc_frontend::compile::SourceMap;
 use qsc_frontend::error::WithSource;
-use symbols::SymbolTable;
 
 use std::path::Path;
 
@@ -26,7 +25,7 @@ pub struct QasmSemanticParseResult {
     pub source: QasmSource,
     pub source_map: SourceMap,
     pub symbols: self::symbols::SymbolTable,
-    pub program: Option<self::ast::Program>,
+    pub program: self::ast::Program,
     pub errors: Vec<WithSource<crate::Error>>,
 }
 
@@ -106,25 +105,14 @@ where
     R: SourceResolver,
 {
     let res = crate::parser::parse_source(source, path, resolver)?;
-    let errors = res.all_errors();
-    // If there are syntax errors, return early
-    if res.source.has_errors() {
-        return Ok(QasmSemanticParseResult {
-            source: res.source,
-            source_map: res.source_map,
-            symbols: SymbolTable::default(),
-            program: None,
-            errors,
-        });
-    }
-
     let analyzer = Lowerer::new(res.source, res.source_map);
     let sem_res = analyzer.lower();
+    let errors = sem_res.all_errors();
     Ok(QasmSemanticParseResult {
         source: sem_res.source,
         source_map: sem_res.source_map,
         symbols: sem_res.symbols,
         program: sem_res.program,
-        errors: sem_res.errors,
+        errors,
     })
 }

compiler/qsc_qasm3/src/semantic/lowerer.rs

@@ -108,7 +108,7 @@ impl Lowerer {
             source: self.source,
             source_map: self.source_map,
             symbols: self.symbols,
-            program: Some(program),
+            program,
             errors: self.errors,
         }
     }

compiler/qsc_qasm3/src/semantic/tests.rs

@@ -133,7 +133,7 @@ pub(super) fn check_stmt_kinds(input: &str, expect: &Expect) {
 fn check_map<S>(
     input: S,
     expect: &Expect,
-    selector: impl FnOnce(&super::ast::Program, &super::SymbolTable) -> String,
+    selector: impl FnOnce(&super::ast::Program, &super::symbols::SymbolTable) -> String,
 ) where
     S: AsRef<str>,
 {
@@ -150,14 +150,12 @@ fn check_map<S>(
         res.sytax_errors()
     );
 
-    let program = res.program.expect("no program");
-
     if errors.is_empty() {
-        expect.assert_eq(&selector(&program, &res.symbols));
+        expect.assert_eq(&selector(&res.program, &res.symbols));
     } else {
         expect.assert_eq(&format!(
             "{}\n\n{:?}",
-            program,
+            res.program,
             errors
                 .iter()
                 .map(|e| Report::new(e.clone()))
@@ -180,7 +178,7 @@ fn check_map_all<P>(
     path: P,
     sources: impl IntoIterator<Item = (Arc<str>, Arc<str>)>,
     expect: &Expect,
-    selector: impl FnOnce(&super::ast::Program, &super::SymbolTable) -> String,
+    selector: impl FnOnce(&super::ast::Program, &super::symbols::SymbolTable) -> String,
 ) where
     P: AsRef<Path>,
 {
@@ -201,14 +199,13 @@ fn check_map_all<P>(
         "syntax errors: {:?}",
         res.sytax_errors()
     );
-    let program = res.program.expect("no program");
 
     if errors.is_empty() {
-        expect.assert_eq(&selector(&program, &res.symbols));
+        expect.assert_eq(&selector(&res.program, &res.symbols));
     } else {
         expect.assert_eq(&format!(
             "{}\n\n{:?}",
-            program,
+            res.program,
             errors
                 .iter()
                 .map(|e| Report::new(e.clone()))