cxx-qt-build: do not panic for cxx_gen failures instead use Result

This allows for CXX errors to appear with a span in the macro expansion

Before this change if you had a unsupported type in an invokable only
the following error would occur.

```
[build]   thread 'main' panicked at 'Could not generate C++ from Rust file:
Syn(Error("unsupported type: QUrl"))', crates/cxx-qt-build/src/lib.rs:120:14
```

Now with this change we have an additional error from the macro expansion.

```
[build] error: unsupported type: QUrl
[build]   --> examples/qml_minimal/rust/src/cxxqt_object.rs:57:35
[build]    |
[build] 57 |         pub fn test(&self, _url: &QUrl) {
[build]    |                                   ^^^^
```

Note however this does cause loads of extra errors below but this is
a side effect of the rest of the CXX macro not being expanded, this first
error is the correct one though.

Related to #38

Author: ahayzen-kdab

crates/cxx-qt-build/src/lib.rs

@@ -34,6 +34,29 @@ use cxx_qt_gen::{
 // QObject macros and at most one "raw CXX" macro per file already. For now this remains a TODO
 // as to keep things simpler. We also want to able to warn users about duplicate names eventually.
 
+/// We need to wrap the CXX and CXX-Qt errors in a single error type so that they
+/// can be returned from the generation phases. This then allows for us to not unwrap
+/// the CXX failures meaning that we can display the macro expansion correctly.
+#[derive(Debug)]
+enum GeneratedError {
+    Cxx(cxx_gen::Error),
+    CxxQt(cxx_qt_gen::Error),
+}
+
+impl From<cxx_gen::Error> for GeneratedError {
+    fn from(err: cxx_gen::Error) -> Self {
+        Self::Cxx(err)
+    }
+}
+
+impl From<cxx_qt_gen::Error> for GeneratedError {
+    fn from(err: cxx_qt_gen::Error) -> Self {
+        Self::CxxQt(err)
+    }
+}
+
+type GeneratedResult<T> = Result<T, GeneratedError>;
+
 struct GeneratedCppFilePaths {
     plain_cpp: PathBuf,
     qobject: Option<PathBuf>,
@@ -54,9 +77,9 @@ struct GeneratedCpp {
 
 impl GeneratedCpp {
     /// Generate QObject and cxx header/source C++ file contents
-    pub fn new(rust_file_path: impl AsRef<Path>) -> cxx_qt_gen::Result<Self> {
+    pub fn new(rust_file_path: impl AsRef<Path>) -> GeneratedResult<Self> {
         let rust_file_path = rust_file_path.as_ref();
-        let file = parse_qt_file(rust_file_path).unwrap();
+        let file = parse_qt_file(rust_file_path)?;
 
         let mut cxx_qt = None;
         let mut qml_metadata = Vec::new();
@@ -123,8 +146,7 @@ impl GeneratedCpp {
         }
 
         let opt = cxx_gen::Opt::default();
-        let cxx = cxx_gen::generate_header_and_cc(tokens, &opt)
-            .expect("Could not generate C++ from Rust file");
+        let cxx = cxx_gen::generate_header_and_cc(tokens, &opt)?;
 
         Ok(GeneratedCpp {
             cxx_qt,
@@ -217,7 +239,7 @@ impl GeneratedCpp {
 fn generate_cxxqt_cpp_files(
     rs_source: &[PathBuf],
     header_dir: impl AsRef<Path>,
-) -> cxx_qt_gen::Result<Vec<GeneratedCppFilePaths>> {
+) -> GeneratedResult<Vec<GeneratedCppFilePaths>> {
     let manifest_dir = env::var("CARGO_MANIFEST_DIR").unwrap();
 
     let mut generated_file_paths: Vec<GeneratedCppFilePaths> = Vec::with_capacity(rs_source.len());