Finish implementation of typescript generator.

The implementation is still untested and will
have issues

libjrpc/src/targets/mod.rs

@@ -1,13 +1,47 @@
+use std::{
+    error::Error,
+    fmt::{Debug, Display},
+};
+
 use anyhow::Result;
 
 use crate::{
     compile::{Compile, CompileContext},
+    ir::Definition,
     IR,
 };
 
 pub mod rust;
 pub mod typescript;
 
+#[derive(Debug, Clone)]
+pub struct CompilerError<D: Definition> {
+    pub message: String,
+    pub definition: D,
+}
+
+impl<D: Definition> CompilerError<D> {
+    fn new(msg: &str, definition: D) -> Self {
+        Self {
+            message: format!("{}: {}", msg, definition.get_name()),
+            definition,
+        }
+    }
+}
+
+impl<D: Definition> Error for CompilerError<D> {}
+
+impl<D: Definition> Display for CompilerError<D> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(
+            f,
+            "CompilerError: {} at {:?}",
+            self.message,
+            self.definition.get_position()
+        )
+    }
+}
+
 pub fn compile<T: Compile>(ir: IR, output: &str) -> Result<()> {
     let mut ctx = CompileContext::new(output);
     let mut compiler = T::new(&ir.options)?;
@@ -15,10 +49,29 @@ pub fn compile<T: Compile>(ir: IR, output: &str) -> Result<()> {
 
     for step in ir.steps.iter() {
         match step {
-            crate::ir::Step::Type(definition) => compiler.generate_type(&mut ctx, &definition)?,
-            crate::ir::Step::Enum(definition) => compiler.generate_enum(&mut ctx, &definition)?,
+            crate::ir::Step::Type(definition) => {
+                match compiler.generate_type(&mut ctx, &definition) {
+                    Ok(_) => (),
+                    Err(err) => {
+                        return Err(CompilerError::new(&err.to_string(), definition.clone()).into())
+                    }
+                }
+            }
+            crate::ir::Step::Enum(definition) => {
+                match compiler.generate_enum(&mut ctx, &definition) {
+                    Ok(_) => (),
+                    Err(err) => {
+                        return Err(CompilerError::new(&err.to_string(), definition.clone()).into())
+                    }
+                }
+            }
             crate::ir::Step::Service(definition) => {
-                compiler.generate_service(&mut ctx, &definition)?
+                match compiler.generate_service(&mut ctx, &definition) {
+                    Ok(_) => (),
+                    Err(err) => {
+                        return Err(CompilerError::new(&err.to_string(), definition.clone()).into())
+                    }
+                }
             }
         }
     }