python_ast/
result.rs

1
2use pyo3::PyErr;
3use thiserror::Error as E;
4
5use crate::{BinOp, BoolOp, Compare, Expr, ExprType, StatementType, UnaryOp};
6
7#[derive(E, Debug)]
8pub enum Error {
9    #[error("BinOp type not yet implemented: {:?}", .0)]
10    BinOpNotYetImplemented(BinOp),
11
12    #[error("BoolOp type not yet implemented: {:?}", .0)]
13    BoolOpNotYetImplemented(BoolOp),
14
15    #[error("Compare type not yet implemented: {:?}", .0)]
16    CompareNotYetImplemented(Compare),
17
18    #[error("Expr type not yet implemented: {:?}", .0)]
19    ExprNotYetImplemented(Expr),
20    #[error("ExprType type not yet implemented: {:?}", .0)]
21    ExprTypeNotYetImplemented(ExprType),
22
23    #[error("Unknown type {0}")]
24    UnknownType(String),
25
26    #[error("PyO3 Error: {0}")]
27    #[from(PyErr)]
28    Pyo3Error(PyErr),
29
30    #[error("Statement type not yet implemented: {:?}", .0)]
31    StatementNotYetImplemented(StatementType),
32    #[error("UnaryOp type not yet implemented: {:?}", .0)]
33    UnaryOpNotYetImplemented(UnaryOp),
34
35    #[error("Unknown Error: {0}")]
36    #[from(Box<dyn std::error::Error>)]
37    UnknownError(Box<dyn std::error::Error>),
38}
39
40pub type Result<T> = std::result::Result<T, Error>;
41
42#[cfg(test)]
43mod tests {
44    use super::*;
45
46    #[test]
47    fn test_error_display_unknown_type() {
48        let error = Error::UnknownType("SomeUnknownType".to_string());
49        let display = format!("{}", error);
50        assert_eq!(display, "Unknown type SomeUnknownType");
51    }
52
53    #[test]
54    fn test_error_display_unknown_error() {
55        let custom_error: Box<dyn std::error::Error> = Box::new(std::io::Error::new(
56            std::io::ErrorKind::NotFound,
57            "Test error"
58        ));
59        let error = Error::UnknownError(custom_error);
60        let display = format!("{}", error);
61        assert!(display.contains("Unknown Error"));
62        assert!(display.contains("Test error"));
63    }
64
65    #[test]
66    fn test_error_debug() {
67        let error = Error::UnknownType("TestType".to_string());
68        let debug = format!("{:?}", error);
69        assert!(debug.contains("UnknownType"));
70        assert!(debug.contains("TestType"));
71    }
72
73    #[test]
74    fn test_result_type_ok() {
75        let result: Result<i32> = Ok(42);
76        assert!(result.is_ok());
77        assert_eq!(result.unwrap(), 42);
78    }
79
80    #[test]
81    fn test_result_type_err() {
82        let result: Result<i32> = Err(Error::UnknownType("TestError".to_string()));
83        assert!(result.is_err());
84        
85        match result {
86            Err(Error::UnknownType(msg)) => assert_eq!(msg, "TestError"),
87            _ => panic!("Expected UnknownType error"),
88        }
89    }
90
91    #[test]
92    fn test_error_chaining() {
93        let result: Result<i32> = Err(Error::UnknownType("ChainTest".to_string()));
94        
95        let chained_result = result.map_err(|e| Error::UnknownError(Box::new(e)));
96        
97        assert!(chained_result.is_err());
98        match chained_result {
99            Err(Error::UnknownError(_)) => (),
100            _ => panic!("Expected chained error"),
101        }
102    }
103}
python_ast/result.rs

python_ast/
result.rs
