vulkan_gen 0.3.0

Vulkan XML specification parser and Rust binding generator. Used internally by the vulkane crate, but reusable as a standalone code generator.
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
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140

//! Generator module traits and common types
//!
//! This module defines the trait that all generator modules must implement
//! and provides common types used across the generation system.

use std::path::Path;
use thiserror::Error;

/// Error type for generator module operations
#[derive(Debug, Error)]
pub enum GeneratorError {
    #[error("IO error: {0}")]
    Io(#[from] std::io::Error),

    #[error("JSON serialization error: {0}")]
    Json(#[from] serde_json::Error),

    #[error("Missing input file: {path}")]
    MissingInput { path: String },

    #[error("Invalid input data: {message}")]
    InvalidInput { message: String },

    #[error("Code generation failed: {message}")]
    CodeGeneration { message: String },

    #[error("Dependency resolution failed: {message}")]
    Dependency { message: String },
}

/// Result type for generator operations
pub type GeneratorResult<T> = Result<T, GeneratorError>;

/// Trait that all generator modules must implement
pub trait GeneratorModule {
    /// Get the name of this generator module
    fn name(&self) -> &str;

    /// Get the list of input files this module expects
    /// These are JSON files from the parsing phase
    fn input_files(&self) -> Vec<String>;

    /// Get the output file this module generates
    fn output_file(&self) -> String;

    /// Get the list of other modules this module depends on
    /// Used for determining generation order
    fn dependencies(&self) -> Vec<String>;

    /// Generate code from input files
    fn generate(&self, input_dir: &Path, output_dir: &Path) -> GeneratorResult<()>;

    /// Get metadata about the generated code
    /// Used by the assembler for dependency resolution
    fn metadata(&self) -> GeneratorMetadata {
        GeneratorMetadata::default()
    }

    /// Collect metadata about defined and used types from input files
    /// This is used for dependency resolution and validation
    fn collect_metadata(&self, _input_dir: &Path) -> GeneratorResult<GeneratorMetadata> {
        Ok(self.metadata())
    }
}

/// Metadata about generated code
#[derive(Debug, Clone, Default)]
pub struct GeneratorMetadata {
    /// Types defined by this module
    pub defined_types: Vec<String>,

    /// Types used but not defined by this module
    pub used_types: Vec<String>,

    /// Whether this module generates forward declarations
    pub has_forward_declarations: bool,

    /// Priority for ordering (lower = generated first)
    pub priority: i32,
}

/// Code fragment generated by a module
#[derive(Debug, Clone)]
pub struct CodeFragment {
    /// The actual generated code
    pub code: String,

    /// Metadata about this fragment
    pub metadata: GeneratorMetadata,

    /// Source module that generated this fragment
    pub source_module: String,
}

impl CodeFragment {
    /// Create a new code fragment
    pub fn new(code: impl Into<String>, source_module: impl Into<String>) -> Self {
        Self {
            code: code.into(),
            metadata: GeneratorMetadata::default(),
            source_module: source_module.into(),
        }
    }

    /// Set metadata for this fragment
    pub fn with_metadata(mut self, metadata: GeneratorMetadata) -> Self {
        self.metadata = metadata;
        self
    }
}

// Export all generator modules
pub mod const_gen;
pub mod device_features_gen;
pub mod enum_gen;
pub mod extensions_builder_gen;
pub mod extensions_gen;
pub mod features_gen;
pub mod function_gen;
pub mod includes_gen;
pub mod macros_gen;
pub mod platforms_gen;
pub mod safe_commands_gen;
pub mod safe_ergonomic_gen;
pub mod safe_handles_gen;
pub mod struct_gen;
pub mod tags_gen;
pub mod type_gen;

pub use const_gen::ConstantGenerator;
pub use enum_gen::EnumGenerator;
pub use extensions_gen::ExtensionGenerator;
pub use features_gen::FeatureGenerator;
pub use function_gen::FunctionGenerator;
pub use includes_gen::IncludeGenerator;
pub use macros_gen::MacroGenerator;
pub use platforms_gen::PlatformGenerator;
pub use struct_gen::StructGenerator;
pub use tags_gen::TagGenerator;
pub use type_gen::TypeGenerator;