Skip to main content

ironsbe_codegen/
error.rs

1//! Error types for code generation.
2
3use thiserror::Error;
4
5/// Error type for code generation operations.
6#[derive(Debug, Error)]
7pub enum CodegenError {
8    /// Schema parsing error.
9    #[error("schema parse error: {0}")]
10    Parse(#[from] ironsbe_schema::ParseError),
11
12    /// Schema validation error.
13    #[error("schema error: {0}")]
14    Schema(#[from] ironsbe_schema::SchemaError),
15
16    /// IO error.
17    #[error("IO error: {0}")]
18    Io(#[from] std::io::Error),
19
20    /// Code generation error.
21    #[error("generation error: {message}")]
22    Generation {
23        /// Error message.
24        message: String,
25    },
26
27    /// Unknown type reference.
28    #[error("unknown type '{type_name}' in field '{field}'")]
29    UnknownType {
30        /// Type name.
31        type_name: String,
32        /// Field name.
33        field: String,
34    },
35}
36
37impl CodegenError {
38    /// Creates a generation error with the given message.
39    pub fn generation(message: impl Into<String>) -> Self {
40        Self::Generation {
41            message: message.into(),
42        }
43    }
44
45    /// Creates an unknown type error.
46    pub fn unknown_type(type_name: impl Into<String>, field: impl Into<String>) -> Self {
47        Self::UnknownType {
48            type_name: type_name.into(),
49            field: field.into(),
50        }
51    }
52}
53
54#[cfg(test)]
55mod tests {
56    use super::*;
57
58    #[test]
59    fn test_codegen_error_generation() {
60        let err = CodegenError::generation("failed to generate code");
61        let msg = err.to_string();
62        assert!(msg.contains("failed to generate code"));
63        assert!(msg.contains("generation error"));
64    }
65
66    #[test]
67    fn test_codegen_error_unknown_type() {
68        let err = CodegenError::unknown_type("MyType", "myField");
69        let msg = err.to_string();
70        assert!(msg.contains("MyType"));
71        assert!(msg.contains("myField"));
72        assert!(msg.contains("unknown type"));
73    }
74
75    #[test]
76    fn test_codegen_error_debug() {
77        let err = CodegenError::generation("test");
78        let debug_str = format!("{:?}", err);
79        assert!(debug_str.contains("Generation"));
80    }
81}