vulkan_gen 0.1.0

//! 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 enum_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 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;