Parsing now bundles IO source loading errors into parse errors. (#2252)

Author: idavis

Diff for: compiler/qsc/src/lib.rs

@@ -76,7 +76,6 @@ pub mod partial_eval {
 }
 
 pub mod qasm3 {
-    pub use qsc_qasm3::io::*;
     pub use qsc_qasm3::parse::*;
     pub use qsc_qasm3::*;
 }

Diff for: 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).map_err(|e| vec![e])?;
+    let unit = compile_all_fragments("source0.qasm", all_sources)?;
     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).map_err(|e| vec![e])?;
+    let unit = compile_all_fragments("source0.qasm", all_sources)?;
     assert!(unit.has_errors());
     for error in unit.errors() {
         assert!(error.to_string().contains("Redefined symbol: "));

Diff for: compiler/qsc_qasm3/src/compiler.rs

@@ -1,7 +1,7 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
-use std::{path::Path, rc::Rc, sync::Arc};
+use std::{path::Path, rc::Rc};
 
 use num_bigint::BigInt;
 use qsc_data_structures::span::Span;
@@ -25,7 +25,6 @@ use crate::{
         build_wrapped_block_expr, managed_qubit_alloc_array, 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::{
@@ -45,48 +44,12 @@ 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>
+pub fn compile_with_config<S, P>(source: S, path: P, config: CompilerConfig) -> QasmCompileUnit
 where
     S: AsRef<str>,
     P: AsRef<Path>,
-    R: SourceResolver,
 {
-    let res = crate::semantic::parse_source(source, path, resolver)?;
+    let res = crate::semantic::parse(source, path);
     let program = res.program;
 
     let compiler = crate::compiler::QasmCompiler {
@@ -98,7 +61,7 @@ where
         errors: res.errors,
     };
 
-    Ok(compiler.compile(&program))
+    compiler.compile(&program)
 }
 
 pub struct QasmCompiler {

Diff for: compiler/qsc_qasm3/src/io.rs

@@ -1,37 +1,38 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
+mod error;
+pub use error::Error;
+pub use error::ErrorKind;
+
 use std::{
     path::{Path, PathBuf},
     sync::Arc,
 };
 
 use rustc_hash::FxHashMap;
 
-use miette::IntoDiagnostic;
-
 /// A trait for resolving include file paths to their contents.
 /// This is used by the parser to resolve `include` directives.
 /// Implementations of this trait can be provided to the parser
 /// to customize how include files are resolved.
 pub trait SourceResolver {
     #[cfg(feature = "fs")]
-    fn resolve<P>(&self, path: P) -> miette::Result<(PathBuf, String)>
+    fn resolve<P>(&self, path: P) -> miette::Result<(PathBuf, String), Error>
     where
         P: AsRef<Path>,
     {
         let path = std::fs::canonicalize(path).map_err(|e| {
-            crate::Error(crate::ErrorKind::IO(format!(
+            Error(ErrorKind::IO(format!(
                 "Could not resolve include file path: {e}"
             )))
         })?;
         match std::fs::read_to_string(&path) {
             Ok(source) => Ok((path, source)),
-            Err(_) => Err(crate::Error(crate::ErrorKind::NotFound(format!(
+            Err(_) => Err(Error(ErrorKind::NotFound(format!(
                 "Could not resolve include file: {}",
                 path.display()
-            ))))
-            .into_diagnostic(),
+            )))),
         }
     }
     #[cfg(not(feature = "fs"))]
@@ -62,18 +63,17 @@ impl FromIterator<(Arc<str>, Arc<str>)> for InMemorySourceResolver {
 }
 
 impl SourceResolver for InMemorySourceResolver {
-    fn resolve<P>(&self, path: P) -> miette::Result<(PathBuf, String)>
+    fn resolve<P>(&self, path: P) -> miette::Result<(PathBuf, String), Error>
     where
         P: AsRef<Path>,
     {
         let path = path.as_ref();
         match self.sources.get(path) {
             Some(source) => Ok((path.to_owned(), source.clone())),
-            None => Err(crate::Error(crate::ErrorKind::NotFound(format!(
+            None => Err(Error(ErrorKind::NotFound(format!(
                 "Could not resolve include file: {}",
                 path.display()
-            ))))
-            .into_diagnostic(),
+            )))),
         }
     }
 }

Diff for: compiler/qsc_qasm3/src/io/error.rs

@@ -0,0 +1,24 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+use miette::Diagnostic;
+use thiserror::Error;
+
+#[derive(Clone, Debug, Diagnostic, Eq, Error, PartialEq)]
+#[error(transparent)]
+#[diagnostic(transparent)]
+pub struct Error(pub ErrorKind);
+
+#[derive(Clone, Debug, Diagnostic, Eq, Error, PartialEq)]
+pub enum ErrorKind {
+    #[error("Not Found {0}")]
+    NotFound(String),
+    #[error("IO Error: {0}")]
+    IO(String),
+}
+
+impl From<Error> for crate::Error {
+    fn from(val: Error) -> Self {
+        crate::Error(crate::ErrorKind::IO(val))
+    }
+}

Diff for: compiler/qsc_qasm3/src/lib.rs

@@ -9,6 +9,7 @@ mod ast_builder;
 mod compile;
 mod compiler;
 pub use compile::qasm_to_program;
+pub use compiler::compile_with_config;
 pub mod io;
 mod keyword;
 mod lex;
@@ -64,6 +65,9 @@ impl Error {
 #[derive(Clone, Debug, Diagnostic, Eq, Error, PartialEq)]
 #[error(transparent)]
 pub enum ErrorKind {
+    #[error(transparent)]
+    #[diagnostic(transparent)]
+    IO(#[from] crate::io::Error),
     #[error("QASM3 Parse Error: {0}")]
     Parse(String, #[label] Span),
     #[error(transparent)]
@@ -75,17 +79,18 @@ pub enum ErrorKind {
     #[error("QASM3 Parse Error: Not Found {0}")]
     NotFound(String),
     #[error("IO Error: {0}")]
-    IO(String),
+    OldIO(String),
 }
 
 impl ErrorKind {
     fn with_offset(self, offset: u32) -> Self {
         match self {
+            ErrorKind::IO(error) => Self::IO(error),
             ErrorKind::Parse(error, span) => Self::Parse(error, span + offset),
             ErrorKind::Parser(error) => Self::Parser(error.with_offset(offset)),
             ErrorKind::Semantic(error) => Self::Semantic(error.with_offset(offset)),
             ErrorKind::NotFound(error) => Self::NotFound(error),
-            ErrorKind::IO(error) => Self::IO(error),
+            ErrorKind::OldIO(error) => Self::OldIO(error),
         }
     }
 }

Diff for: compiler/qsc_qasm3/src/parser.rs

@@ -110,14 +110,14 @@ fn update_offsets(source_map: &SourceMap, source: &mut QasmSource) {
 /// This function will resolve includes using the provided resolver.
 /// If an include file cannot be resolved, an error will be returned.
 /// If a file is included recursively, a stack overflow occurs.
-pub fn parse_source<S, P, R>(source: S, path: P, resolver: &R) -> miette::Result<QasmParseResult>
+pub fn parse_source<S, P, R>(source: S, path: P, resolver: &R) -> QasmParseResult
 where
     S: AsRef<str>,
     P: AsRef<Path>,
     R: SourceResolver,
 {
-    let res = parse_qasm_source(source, path, resolver)?;
-    Ok(QasmParseResult::new(res))
+    let res = parse_qasm_source(source, path, resolver);
+    QasmParseResult::new(res)
 }
 
 /// Creates a Q# source map from a QASM parse output. The `QasmSource`
@@ -230,38 +230,54 @@ impl QasmSource {
 /// This function is the start of a recursive process that will resolve all
 /// includes in the QASM file. Any includes are parsed as if their contents
 /// were defined where the include statement is.
-fn parse_qasm_file<P, R>(path: P, resolver: &R) -> miette::Result<QasmSource>
+fn parse_qasm_file<P, R>(path: P, resolver: &R) -> QasmSource
 where
     P: AsRef<Path>,
     R: SourceResolver,
 {
-    let (path, source) = resolver.resolve(&path)?;
-    parse_qasm_source(source, path, resolver)
+    match resolver.resolve(&path) {
+        Ok((path, source)) => parse_qasm_source(source, path, resolver),
+        Err(e) => {
+            let error = crate::parser::error::ErrorKind::IO(e);
+            let error = crate::parser::Error(error, None);
+            QasmSource {
+                path: path.as_ref().to_owned(),
+                source: Default::default(),
+                program: Program {
+                    span: Span::default(),
+                    statements: vec![].into_boxed_slice(),
+                    version: None,
+                },
+                errors: vec![error],
+                included: vec![],
+            }
+        }
+    }
 }
 
-fn parse_qasm_source<S, P, R>(source: S, path: P, resolver: &R) -> miette::Result<QasmSource>
+fn parse_qasm_source<S, P, R>(source: S, path: P, resolver: &R) -> QasmSource
 where
     S: AsRef<str>,
     P: AsRef<Path>,
     R: SourceResolver,
 {
-    let (program, errors, includes) = parse_source_and_includes(source.as_ref(), resolver)?;
-    Ok(QasmSource::new(source, path, program, errors, includes))
+    let (program, errors, includes) = parse_source_and_includes(source.as_ref(), resolver);
+    QasmSource::new(source, path, program, errors, includes)
 }
 
 fn parse_source_and_includes<P: AsRef<str>, R>(
     source: P,
     resolver: &R,
-) -> miette::Result<(Program, Vec<Error>, Vec<QasmSource>)>
+) -> (Program, Vec<Error>, Vec<QasmSource>)
 where
     R: SourceResolver,
 {
-    let (program, errors) = parse(source.as_ref())?;
-    let included = parse_includes(&program, resolver)?;
-    Ok((program, errors, included))
+    let (program, errors) = parse(source.as_ref());
+    let included = parse_includes(&program, resolver);
+    (program, errors, included)
 }
 
-fn parse_includes<R>(program: &Program, resolver: &R) -> miette::Result<Vec<QasmSource>>
+fn parse_includes<R>(program: &Program, resolver: &R) -> Vec<QasmSource>
 where
     R: SourceResolver,
 {
@@ -274,12 +290,12 @@ where
             if file_path.to_lowercase() == "stdgates.inc" {
                 continue;
             }
-            let source = parse_qasm_file(file_path, resolver)?;
+            let source = parse_qasm_file(file_path, resolver);
             includes.push(source);
         }
     }
 
-    Ok(includes)
+    includes
 }
 
 pub(crate) type Result<T> = std::result::Result<T, crate::parser::error::Error>;
@@ -288,8 +304,9 @@ pub(crate) trait Parser<T>: FnMut(&mut ParserContext) -> Result<T> {}
 
 impl<T, F: FnMut(&mut ParserContext) -> Result<T>> Parser<T> for F {}
 
-pub fn parse(input: &str) -> Result<(Program, Vec<Error>)> {
+#[must_use]
+pub fn parse(input: &str) -> (Program, Vec<Error>) {
     let mut scanner = ParserContext::new(input);
-    let program = prgm::parse(&mut scanner)?;
-    Ok((program, scanner.into_errors()))
+    let program = prgm::parse(&mut scanner);
+    (program, scanner.into_errors())
 }

Diff for: compiler/qsc_qasm3/src/parser/error.rs

@@ -137,6 +137,9 @@ pub enum ErrorKind {
     #[error("multiple index operators are only allowed in assignments")]
     #[diagnostic(code("Qasm3.Parse.MultipleIndexOperators"))]
     MultipleIndexOperators(#[label] Span),
+    #[error(transparent)]
+    #[diagnostic(transparent)]
+    IO(#[from] crate::io::Error),
 }
 
 impl ErrorKind {
@@ -160,6 +163,13 @@ impl ErrorKind {
             Self::GPhaseInvalidArguments(span) => Self::GPhaseInvalidArguments(span + offset),
             Self::InvalidGateCallDesignator(span) => Self::InvalidGateCallDesignator(span + offset),
             Self::MultipleIndexOperators(span) => Self::MultipleIndexOperators(span + offset),
+            Self::IO(error) => Self::IO(error),
         }
     }
 }
+
+impl From<Error> for crate::Error {
+    fn from(val: Error) -> Self {
+        crate::Error(crate::ErrorKind::Parser(val))
+    }
+}

Diff for: compiler/qsc_qasm3/src/parser/prgm.rs

@@ -15,20 +15,20 @@ use super::ast::{Program, Stmt, StmtKind, Version};
 use super::ParserContext;
 
 /// Grammar: `version? statementOrScope* EOF`.
-pub(super) fn parse(s: &mut ParserContext) -> Result<Program> {
+pub(super) fn parse(s: &mut ParserContext) -> Program {
     let lo = s.peek().span.lo;
-    let version = opt(s, parse_version)?;
-    let stmts = parse_top_level_nodes(s)?;
+    let version = opt(s, parse_version).unwrap_or_default();
+    let stmts = parse_top_level_nodes(s).unwrap_or_default();
 
-    Ok(Program {
+    Program {
         span: s.span(lo),
         version,
         statements: stmts
             .into_iter()
             .map(Box::new)
             .collect::<Vec<_>>()
             .into_boxed_slice(),
-    })
+    }
 }
 
 /// Grammar: `OPENQASM VersionSpecifier SEMICOLON`.