python-ast 1.1.0

A library for compiling Python to Rust
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86

/// Macros for reducing code duplication in the python-ast library.

/// Macro for generating test functions for AST parsing.
/// Reduces duplication in test code. Asserts that both parsing and code
/// generation succeed and that the generated stream is non-empty, so codegen
/// regressions actually fail the test.
#[macro_export]
macro_rules! create_parse_test {
    ($test_name:ident, $code:literal, $file_name:literal) => {
        #[test]
        fn $test_name() {
            let options = PythonOptions::default();
            let result = crate::parse($code, $file_name)
                .unwrap_or_else(|e| panic!("failed to parse {:?}: {}", $code, e));
            tracing::info!("Python tree: {:?}", result);

            let symbols = result.clone().find_symbols(SymbolTableScopes::new());
            let code = result
                .to_rust(
                    CodeGenContext::Module($file_name.replace(".py", "").to_string()),
                    options,
                    symbols,
                )
                .unwrap_or_else(|e| panic!("failed to generate code for {:?}: {}", $code, e));
            tracing::info!("Generated code: {}", code);
            assert!(
                !code.to_string().trim().is_empty(),
                "codegen produced empty output for {:?}",
                $code
            );
        }
    };
}

/// Macro for generating Node trait implementations with optional position fields.
/// This macro automatically implements the Node trait for types that have position fields.
#[macro_export]
macro_rules! impl_node_with_positions {
    ($type_name:ident { $($field:ident),* }) => {
        impl $crate::Node for $type_name {
            fn lineno(&self) -> Option<usize> {
                $(
                    if stringify!($field) == "lineno" {
                        return self.$field;
                    }
                )*
                None
            }

            fn col_offset(&self) -> Option<usize> {
                $(
                    if stringify!($field) == "col_offset" {
                        return self.$field;
                    }
                )*
                None
            }

            fn end_lineno(&self) -> Option<usize> {
                $(
                    if stringify!($field) == "end_lineno" {
                        return self.$field;
                    }
                )*
                None
            }

            fn end_col_offset(&self) -> Option<usize> {
                $(
                    if stringify!($field) == "end_col_offset" {
                        return self.$field;
                    }
                )*
                None
            }
        }
    };
    
    // Variant for types without position fields
    ($type_name:ident) => {
        impl $crate::Node for $type_name {
            // All methods return None (default implementation)
        }
    };
}