ryo_analysis/check/

checker.rs

//! GraphChecker - Lightweight graph-based validation.

use super::result::{CheckError, CheckResult};
use super::traits::LightCheck;
use crate::query::{CodeGraphV2, StdImplCache, TypeFlowGraphV2};
use crate::symbol::{SymbolPath, SymbolRegistry};

/// Lightweight graph-based checker for pre-mutation validation.
///
/// Uses the existing `CodeGraphV2` and `SymbolRegistry` to quickly validate
/// that mutations are likely to succeed, without running the full compiler.
///
/// # Performance Target
///
/// | Operation | Target | vs cargo check |
/// |-----------|--------|----------------|
/// | Symbol exists | < 1ms | N/A |
/// | Trait impl check | < 5ms | N/A |
/// | Derive possible | < 50ms | 100x faster |
/// | Full pre-check | < 100ms | 50-100x faster |
pub struct GraphChecker<'a> {
    graph: &'a CodeGraphV2,
    typeflow: &'a TypeFlowGraphV2,
    registry: &'a SymbolRegistry,
    std_impls: StdImplCache,
}

impl<'a> GraphChecker<'a> {
    /// Create a new GraphChecker.
    pub fn new(
        graph: &'a CodeGraphV2,
        typeflow: &'a TypeFlowGraphV2,
        registry: &'a SymbolRegistry,
    ) -> Self {
        Self {
            graph,
            typeflow,
            registry,
            std_impls: StdImplCache::default(),
        }
    }

    /// Create a checker with a custom std impls cache.
    pub fn with_std_impls(
        graph: &'a CodeGraphV2,
        typeflow: &'a TypeFlowGraphV2,
        registry: &'a SymbolRegistry,
        std_impls: StdImplCache,
    ) -> Self {
        Self {
            graph,
            typeflow,
            registry,
            std_impls,
        }
    }

    // === Symbol Existence Checks ===

    /// Check if a symbol exists in the registry.
    ///
    /// Searches both by full path and by short name.
    ///
    /// # Examples
    /// ```rust,ignore
    /// let checker = GraphChecker::new(&graph, &registry);
    ///
    /// // Full path lookup
    /// assert!(checker.check_symbol_exists("my_crate::MyStruct"));
    ///
    /// // Short name lookup (finds my_crate::MyStruct)
    /// assert!(checker.check_symbol_exists("MyStruct"));
    /// ```
    pub fn check_symbol_exists(&self, name: &str) -> bool {
        // 1. Try as full path
        if let Ok(path) = SymbolPath::parse(name) {
            if self.registry.lookup(&path).is_some() {
                return true;
            }
        }

        // 2. Try as short name
        !self.registry.find_by_name(name).is_empty()
    }

    /// Check if a symbol exists and return suggestions if not.
    pub fn check_symbol_with_suggestions(&self, name: &str) -> Result<(), CheckError> {
        if self.check_symbol_exists(name) {
            Ok(())
        } else {
            // Try to find similar names for suggestions
            let suggestions = self.find_similar_symbols(name);
            Err(CheckError::UnresolvedRef {
                name: name.to_string(),
                location: None,
                suggestions,
            })
        }
    }

    /// Check if a symbol is unique (exactly one match).
    ///
    /// Returns the SymbolId if exactly one symbol matches, error otherwise.
    /// - If no symbols found: UnresolvedRef error
    /// - If multiple symbols found: AmbiguousTarget error
    ///
    /// # Examples
    /// ```rust,ignore
    /// let checker = GraphChecker::new(&graph, &registry);
    ///
    /// // Unique symbol - returns SymbolId
    /// let id = checker.check_symbol_unique("Config")?;
    ///
    /// // Multiple Config in different modules - AmbiguousTarget error
    /// // e.g., my_crate::config::Config and my_crate::settings::Config
    /// ```
    pub fn check_symbol_unique(&self, name: &str) -> Result<crate::SymbolId, CheckError> {
        // 1. Try as full path first (always unique)
        if let Ok(path) = SymbolPath::parse(name) {
            if let Some(id) = self.registry.lookup(&path) {
                return Ok(id);
            }
        }

        // 2. Search by short name
        let matches = self.registry.find_by_name(name);

        match matches.len() {
            0 => {
                let suggestions = self.find_similar_symbols(name);
                Err(CheckError::UnresolvedRef {
                    name: name.to_string(),
                    location: None,
                    suggestions,
                })
            }
            1 => Ok(matches[0]),
            _ => {
                // Multiple matches - ambiguous
                let candidates: Vec<String> = matches
                    .iter()
                    .filter_map(|id| self.registry.resolve(*id).map(|p| p.to_string()))
                    .collect();
                Err(CheckError::ambiguous_target(name, candidates))
            }
        }
    }

    /// Find symbols with similar names (for error suggestions).
    fn find_similar_symbols(&self, name: &str) -> Vec<String> {
        let name_lower = name.to_lowercase();
        let mut suggestions = Vec::new();

        for (_, path) in self.registry.iter() {
            let sym_name = path.name();
            // Simple similarity: starts with same chars or contains the name
            if sym_name
                .to_lowercase()
                .starts_with(&name_lower[..name_lower.len().min(3)])
                || sym_name.to_lowercase().contains(&name_lower)
            {
                suggestions.push(path.to_string());
                if suggestions.len() >= 3 {
                    break;
                }
            }
        }

        suggestions
    }

    // === Trait Implementation Checks ===

    /// Check if a type implements a trait.
    ///
    /// First checks the std impls cache, then searches the CodeGraph
    /// for Implements edges.
    pub fn check_trait_impl(&self, type_name: &str, trait_name: &str) -> bool {
        // 1. Check std impls cache first (primitives, common std types)
        if self.std_impls.has_impl(type_name, trait_name) {
            return true;
        }

        // 2. Check CodeGraphV2 for Implements edges
        let type_id = self.registry.lookup_by_name(type_name);
        let trait_id = self.registry.lookup_by_name(trait_name);

        match (type_id, trait_id) {
            (Some(tid), Some(trid)) => self.graph.implementors_of(trid).any(|id| id == tid),
            _ => {
                // If we can't find the symbols, check if type is a std type
                // that might be parameterized (Vec<T>, Option<T>, etc.)
                self.check_generic_std_impl(type_name, trait_name)
            }
        }
    }

    /// Check generic std type implementations.
    ///
    /// For types like `Vec<T>`, `Option<T>`, we check if the base type
    /// implements the trait (conditional on T implementing it).
    fn check_generic_std_impl(&self, type_name: &str, trait_name: &str) -> bool {
        // Extract base type from generics: "Vec<Foo>" -> "Vec"
        let base_type = type_name.split('<').next().unwrap_or(type_name).trim();

        if self.std_impls.is_std_container(base_type) {
            // For std containers, check if the base type has the impl
            // (actual validity depends on T, which we can't check here)
            self.std_impls.has_impl(base_type, trait_name)
        } else {
            false
        }
    }

    // === Derive Possibility Checks ===

    /// Check if a derive macro can be applied to a type.
    ///
    /// Verifies that all fields of the type implement the required trait.
    ///
    /// # Returns
    /// - `CheckResult::Ok` if derive is possible
    /// - `CheckResult::Error` with missing implementations
    pub fn check_derive_possible(&self, target: &str, trait_name: &str) -> CheckResult {
        // 1. Find the target type
        let target_id = match self.registry.lookup_by_name(target) {
            Some(id) => id,
            None => {
                return CheckResult::Error(vec![CheckError::type_not_found(target)]);
            }
        };

        // 2. Get fields (children with Contains edge)
        let children: Vec<_> = self.graph.children_of(target_id).collect();

        if children.is_empty() {
            // No fields - derive is always possible
            return CheckResult::Ok;
        }

        // 3. Check each field's type
        let mut missing = Vec::new();

        for child_id in children.into_iter() {
            // Get the field's type
            if let Some(field_type) = self.get_field_type(child_id) {
                if !self.check_trait_impl(&field_type, trait_name) {
                    // Check if it's a type we know about
                    if !self.std_impls.is_primitive(&field_type)
                        && !self.std_impls.is_std_container(&field_type)
                        && self.registry.lookup_by_name(&field_type).is_none()
                    {
                        // Unknown type - might be OK, add as warning candidate
                        // For now, we're conservative and allow it
                        continue;
                    }
                    missing.push(field_type);
                }
            }
        }

        if missing.is_empty() {
            CheckResult::Ok
        } else {
            CheckResult::Error(vec![CheckError::derive_failed(target, trait_name, missing)])
        }
    }

    /// Get the type of a field.
    ///
    /// This is a simplified version - in reality we'd need to look at
    /// the AST or type information stored in DetailStore.
    fn get_field_type(&self, field_id: crate::SymbolId) -> Option<String> {
        // Get types used by this field (via TypeFlow)
        for use_id in self.typeflow.types_used_by(field_id) {
            if let Some(path) = self.registry.resolve(use_id) {
                return Some(path.name().to_string());
            }
        }

        None
    }

    // === Member Access Checks ===

    /// Check if a struct/type has a specific field.
    ///
    /// Returns Ok if the field exists, Error with available fields if not.
    ///
    /// # Examples
    /// ```rust,ignore
    /// let checker = GraphChecker::new(&graph, &registry);
    ///
    /// // Check if Payment has a 'created_at' field
    /// match checker.check_field_exists("Payment", "created_at") {
    ///     Ok(()) => { /* field exists */ }
    ///     Err(e) => { /* field not found, e contains suggestions */ }
    /// }
    /// ```
    pub fn check_field_exists(&self, type_name: &str, field_name: &str) -> Result<(), CheckError> {
        let type_id = match self.registry.lookup_by_name(type_name) {
            Some(id) => id,
            None => {
                return Err(CheckError::type_not_found(type_name));
            }
        };

        // Get all children (fields) of this type
        let children: Vec<_> = self.graph.children_of(type_id).collect();
        let mut available_fields = Vec::new();

        for child_id in &children {
            if let Some(path) = self.registry.resolve(*child_id) {
                let name = path.name();
                if name == field_name {
                    return Ok(());
                }
                available_fields.push(name.to_string());
            }
        }

        Err(CheckError::field_not_found(
            type_name,
            field_name,
            available_fields,
        ))
    }

    /// Check if a type has a specific method.
    ///
    /// Searches for methods by looking up `TypeName::method_name` pattern
    /// and checking direct children of the type.
    pub fn check_method_exists(
        &self,
        type_name: &str,
        method_name: &str,
    ) -> Result<(), CheckError> {
        // First verify the type exists
        let type_id = match self.registry.lookup_by_name(type_name) {
            Some(id) => id,
            None => {
                return Err(CheckError::type_not_found(type_name));
            }
        };

        // Try direct lookup: TypeName::method_name
        let qualified_name = format!("{}::{}", type_name, method_name);
        if self.registry.lookup_by_name(&qualified_name).is_some() {
            return Ok(());
        }

        // Search for methods as children of the type
        let mut available_methods = Vec::new();
        for child_id in self.graph.children_of(type_id) {
            if let Some(path) = self.registry.resolve(child_id) {
                let name = path.name();
                // Check if it's a function-like symbol
                if let Some(kind) = self.registry.kind(child_id) {
                    if matches!(
                        kind,
                        crate::SymbolKind::Function | crate::SymbolKind::Method
                    ) {
                        if name == method_name {
                            return Ok(());
                        }
                        available_methods.push(name.to_string());
                    }
                }
            }
        }

        // Search registry for symbols containing the type name and method name
        for (_, path) in self.registry.iter() {
            let path_str = path.to_string();
            // Look for patterns like:
            // - "crate::module::TypeName::method_name"
            // - "crate::<impl TypeName>::method_name"
            // Note: The actual format is `<impl TypeName>`, not `impl<TypeName>`
            let impl_pattern_correct = format!("<impl {}>", type_name);
            if (path_str.contains(&format!("{}::{}", type_name, method_name))
                || path_str.contains(&impl_pattern_correct))
                && path.name() == method_name
            {
                return Ok(());
            }
            // Collect available methods for suggestions
            if path_str.contains(type_name) {
                if let Some(kind) = self
                    .registry
                    .lookup(path)
                    .and_then(|id| self.registry.kind(id))
                {
                    if matches!(
                        kind,
                        crate::SymbolKind::Function | crate::SymbolKind::Method
                    ) && !available_methods.contains(&path.name().to_string())
                    {
                        available_methods.push(path.name().to_string());
                    }
                }
            }
        }

        Err(CheckError::method_not_found(
            type_name,
            method_name,
            available_methods,
        ))
    }

    /// Check if an enum has a specific variant.
    pub fn check_enum_variant_exists(
        &self,
        enum_name: &str,
        variant_name: &str,
    ) -> Result<(), CheckError> {
        let enum_id = match self.registry.lookup_by_name(enum_name) {
            Some(id) => id,
            None => {
                return Err(CheckError::type_not_found(enum_name));
            }
        };

        // Get all children (variants) of this enum
        let children: Vec<_> = self.graph.children_of(enum_id).collect();
        let mut available_variants = Vec::new();

        for child_id in &children {
            if let Some(path) = self.registry.resolve(*child_id) {
                let name = path.name();
                if name == variant_name {
                    return Ok(());
                }
                available_variants.push(name.to_string());
            }
        }

        Err(CheckError::variant_not_found(
            enum_name,
            variant_name,
            available_variants,
        ))
    }

    /// Check if all required fields are provided for a struct literal.
    ///
    /// Returns Ok if all fields are covered, Error with missing fields if not.
    pub fn check_struct_fields_complete(
        &self,
        struct_name: &str,
        provided_fields: &[&str],
    ) -> Result<(), CheckError> {
        let struct_id = match self.registry.lookup_by_name(struct_name) {
            Some(id) => id,
            None => {
                return Err(CheckError::type_not_found(struct_name));
            }
        };

        // Get all fields of this struct
        let children: Vec<_> = self.graph.children_of(struct_id).collect();
        let mut missing_fields = Vec::new();

        for child_id in &children {
            if let Some(path) = self.registry.resolve(*child_id) {
                let field_name = path.name();
                // Check if it's a field (not a method)
                if let Some(kind) = self.registry.kind(*child_id) {
                    if matches!(kind, crate::SymbolKind::Field)
                        && !provided_fields.contains(&field_name)
                    {
                        missing_fields.push(field_name.to_string());
                    }
                }
            }
        }

        if missing_fields.is_empty() {
            Ok(())
        } else {
            Err(CheckError::missing_fields(struct_name, missing_fields))
        }
    }

    /// Get the expected argument count for a function.
    ///
    /// Returns None if the function is not found or count cannot be determined.
    pub fn get_function_arg_count(&self, fn_name: &str) -> Option<usize> {
        let fn_id = self.registry.lookup_by_name(fn_name)?;

        // Count parameter children
        let param_count = self
            .graph
            .children_of(fn_id)
            .filter(|child_id| {
                self.registry
                    .kind(*child_id)
                    .map(|k| matches!(k, crate::SymbolKind::Parameter))
                    .unwrap_or(false)
            })
            .count();

        Some(param_count)
    }

    /// Check if the argument count matches for a function call.
    pub fn check_function_arg_count(
        &self,
        fn_name: &str,
        actual_count: usize,
    ) -> Result<(), CheckError> {
        match self.get_function_arg_count(fn_name) {
            Some(expected) if expected != actual_count => Err(CheckError::arg_count_mismatch(
                fn_name,
                expected,
                actual_count,
            )),
            Some(_) => Ok(()),
            None => {
                // Function not found or count unknown - allow it (conservative)
                Ok(())
            }
        }
    }

    // === Batch Checks ===

    /// Check multiple symbols exist.
    pub fn check_symbols_exist(&self, names: &[&str]) -> CheckResult {
        let mut errors = Vec::new();

        for name in names {
            if !self.check_symbol_exists(name) {
                errors.push(CheckError::unresolved(*name));
            }
        }

        if errors.is_empty() {
            CheckResult::Ok
        } else {
            CheckResult::Error(errors)
        }
    }

    /// Check multiple trait implementations.
    pub fn check_trait_impls(&self, checks: &[(&str, &str)]) -> CheckResult {
        let mut errors = Vec::new();

        for (type_name, trait_name) in checks {
            if !self.check_trait_impl(type_name, trait_name) {
                errors.push(CheckError::trait_not_impl(*type_name, *trait_name));
            }
        }

        if errors.is_empty() {
            CheckResult::Ok
        } else {
            CheckResult::Error(errors)
        }
    }

    // === Accessors ===

    /// Get a reference to the CodeGraphV2.
    pub fn graph(&self) -> &CodeGraphV2 {
        self.graph
    }

    /// Get a reference to the SymbolRegistry.
    pub fn registry(&self) -> &SymbolRegistry {
        self.registry
    }

    /// Get a reference to the StdImplCache.
    pub fn std_impls(&self) -> &StdImplCache {
        &self.std_impls
    }
}

impl LightCheck for GraphChecker<'_> {
    fn check_symbol_exists(&self, name: &str) -> bool {
        GraphChecker::check_symbol_exists(self, name)
    }

    fn check_trait_impl(&self, type_name: &str, trait_name: &str) -> bool {
        GraphChecker::check_trait_impl(self, type_name, trait_name)
    }

    fn check_derive_possible(&self, target: &str, trait_name: &str) -> CheckResult {
        GraphChecker::check_derive_possible(self, target, trait_name)
    }

    fn pre_check(&self, mutation_type: &str, target: &str) -> CheckResult {
        match mutation_type {
            "AddDerive" => {
                // For AddDerive, check if the target type exists
                if !self.check_symbol_exists(target) {
                    return CheckResult::Error(vec![CheckError::type_not_found(target)]);
                }
                CheckResult::Ok
            }
            "RenameSymbol" => {
                // For rename, check if source exists
                if !self.check_symbol_exists(target) {
                    return CheckResult::Error(vec![CheckError::unresolved(target)]);
                }
                CheckResult::Ok
            }
            _ => CheckResult::Ok,
        }
    }

    fn post_check(&self, mutation_type: &str, target: &str) -> CheckResult {
        match mutation_type {
            "RenameSymbol" => {
                // After rename, the new symbol should exist
                if !self.check_symbol_exists(target) {
                    return CheckResult::Error(vec![CheckError::unresolved(target)]);
                }
                CheckResult::Ok
            }
            _ => CheckResult::Ok,
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::query::GraphBuilderV2;
    use crate::SymbolKind;

    fn setup_test_env() -> (CodeGraphV2, TypeFlowGraphV2, SymbolRegistry) {
        let mut registry = SymbolRegistry::new();
        let mut builder = GraphBuilderV2::new(&mut registry);

        // Register some test symbols
        let my_struct = builder
            .add_symbol(
                SymbolPath::parse("test::MyStruct").unwrap(),
                SymbolKind::Struct,
            )
            .unwrap();
        let field = builder
            .add_symbol(
                SymbolPath::parse("test::MyStruct::field").unwrap(),
                SymbolKind::Field,
            )
            .unwrap();
        let i32_type = builder
            .add_symbol(
                SymbolPath::parse("std::i32").unwrap(),
                SymbolKind::TypeAlias,
            )
            .unwrap();

        builder.add_contains(my_struct, field);

        let graph = builder.build();
        let mut typeflow = TypeFlowGraphV2::new();
        // Register field -> i32 type usage in TypeFlow
        typeflow.add_usage(
            crate::query::UsageContext::FieldType,
            crate::query::RefKind::Owned,
            Some(i32_type),
            Some(field),
        );
        (graph, typeflow, registry)
    }

    #[test]
    fn test_check_symbol_exists() {
        let (graph, typeflow, registry) = setup_test_env();
        let checker = GraphChecker::new(&graph, &typeflow, &registry);

        // Full path lookup
        assert!(checker.check_symbol_exists("test::MyStruct"));

        // Short name lookup
        assert!(checker.check_symbol_exists("MyStruct"));

        // Non-existent
        assert!(!checker.check_symbol_exists("NonExistent"));
    }

    #[test]
    fn test_check_trait_impl_primitives() {
        let (graph, typeflow, registry) = setup_test_env();
        let checker = GraphChecker::new(&graph, &typeflow, &registry);

        // Primitives from std cache
        assert!(checker.check_trait_impl("i32", "Clone"));
        assert!(checker.check_trait_impl("i32", "Default"));
        assert!(checker.check_trait_impl("bool", "Eq"));

        // f64 doesn't have Eq
        assert!(!checker.check_trait_impl("f64", "Eq"));
    }

    #[test]
    fn test_check_trait_impl_std_types() {
        let (graph, typeflow, registry) = setup_test_env();
        let checker = GraphChecker::new(&graph, &typeflow, &registry);

        assert!(checker.check_trait_impl("String", "Clone"));
        assert!(checker.check_trait_impl("Vec", "Default"));
        assert!(checker.check_trait_impl("HashMap", "Default"));
    }

    #[test]
    fn test_batch_symbol_check() {
        let (graph, typeflow, registry) = setup_test_env();
        let checker = GraphChecker::new(&graph, &typeflow, &registry);

        // All exist
        let result = checker.check_symbols_exist(&["MyStruct", "field"]);
        assert!(result.is_ok());

        // One missing
        let result = checker.check_symbols_exist(&["MyStruct", "NonExistent"]);
        assert!(result.is_err());
        assert_eq!(result.errors().len(), 1);
    }

    // === Member Access Tests ===

    fn setup_extended_test_env() -> (CodeGraphV2, TypeFlowGraphV2, SymbolRegistry) {
        let mut registry = SymbolRegistry::new();
        let mut builder = GraphBuilderV2::new(&mut registry);

        // Struct with fields
        let payment = builder
            .add_symbol(
                SymbolPath::parse("test::Payment").unwrap(),
                SymbolKind::Struct,
            )
            .unwrap();
        let amount_field = builder
            .add_symbol(
                SymbolPath::parse("test::Payment::amount").unwrap(),
                SymbolKind::Field,
            )
            .unwrap();
        let processed_at_field = builder
            .add_symbol(
                SymbolPath::parse("test::Payment::processed_at").unwrap(),
                SymbolKind::Field,
            )
            .unwrap();
        builder.add_contains(payment, amount_field);
        builder.add_contains(payment, processed_at_field);

        // Struct with method
        let order_id = builder
            .add_symbol(
                SymbolPath::parse("test::OrderId").unwrap(),
                SymbolKind::Struct,
            )
            .unwrap();
        let new_method = builder
            .add_symbol(
                SymbolPath::parse("test::OrderId::new").unwrap(),
                SymbolKind::Function,
            )
            .unwrap();
        builder.add_contains(order_id, new_method);

        // Enum with variants
        let status = builder
            .add_symbol(
                SymbolPath::parse("test::ProductStatus").unwrap(),
                SymbolKind::Enum,
            )
            .unwrap();
        let active = builder
            .add_symbol(
                SymbolPath::parse("test::ProductStatus::Active").unwrap(),
                SymbolKind::Variant,
            )
            .unwrap();
        let discontinued = builder
            .add_symbol(
                SymbolPath::parse("test::ProductStatus::Discontinued").unwrap(),
                SymbolKind::Variant,
            )
            .unwrap();
        builder.add_contains(status, active);
        builder.add_contains(status, discontinued);

        let graph = builder.build();
        let typeflow = TypeFlowGraphV2::new();
        (graph, typeflow, registry)
    }

    #[test]
    fn test_check_field_exists() {
        let (graph, typeflow, registry) = setup_extended_test_env();
        let checker = GraphChecker::new(&graph, &typeflow, &registry);

        // Existing fields
        assert!(checker.check_field_exists("Payment", "amount").is_ok());
        assert!(checker
            .check_field_exists("Payment", "processed_at")
            .is_ok());

        // Non-existent field (with suggestions)
        let result = checker.check_field_exists("Payment", "created_at");
        assert!(result.is_err());
        if let Err(CheckError::FieldNotFound {
            type_name,
            field_name,
            available_fields,
        }) = result
        {
            assert_eq!(type_name, "Payment");
            assert_eq!(field_name, "created_at");
            assert!(available_fields.contains(&"amount".to_string()));
            assert!(available_fields.contains(&"processed_at".to_string()));
        } else {
            panic!("Expected FieldNotFound error");
        }

        // Non-existent type
        assert!(matches!(
            checker.check_field_exists("NonExistent", "field"),
            Err(CheckError::TypeNotFound { .. })
        ));
    }

    #[test]
    fn test_check_method_exists() {
        let (graph, typeflow, registry) = setup_extended_test_env();
        let checker = GraphChecker::new(&graph, &typeflow, &registry);

        // Existing method
        assert!(checker.check_method_exists("OrderId", "new").is_ok());

        // Non-existent method
        let result = checker.check_method_exists("OrderId", "as_u64");
        assert!(result.is_err());
        if let Err(CheckError::MethodNotFound {
            type_name,
            method_name,
            ..
        }) = result
        {
            assert_eq!(type_name, "OrderId");
            assert_eq!(method_name, "as_u64");
        } else {
            panic!("Expected MethodNotFound error");
        }
    }

    #[test]
    fn test_check_enum_variant_exists() {
        let (graph, typeflow, registry) = setup_extended_test_env();
        let checker = GraphChecker::new(&graph, &typeflow, &registry);

        // Existing variants
        assert!(checker
            .check_enum_variant_exists("ProductStatus", "Active")
            .is_ok());
        assert!(checker
            .check_enum_variant_exists("ProductStatus", "Discontinued")
            .is_ok());

        // Non-existent variant (with suggestions)
        let result = checker.check_enum_variant_exists("ProductStatus", "Inactive");
        assert!(result.is_err());
        if let Err(CheckError::EnumVariantNotFound {
            enum_name,
            variant_name,
            available_variants,
        }) = result
        {
            assert_eq!(enum_name, "ProductStatus");
            assert_eq!(variant_name, "Inactive");
            assert!(available_variants.contains(&"Active".to_string()));
            assert!(available_variants.contains(&"Discontinued".to_string()));
        } else {
            panic!("Expected EnumVariantNotFound error");
        }
    }

    #[test]
    fn test_check_struct_fields_complete() {
        let (graph, typeflow, registry) = setup_extended_test_env();
        let checker = GraphChecker::new(&graph, &typeflow, &registry);

        // All fields provided
        let result = checker.check_struct_fields_complete("Payment", &["amount", "processed_at"]);
        assert!(result.is_ok());

        // Missing field
        let result = checker.check_struct_fields_complete("Payment", &["amount"]);
        assert!(result.is_err());
        if let Err(CheckError::MissingRequiredField {
            struct_name,
            missing_fields,
        }) = result
        {
            assert_eq!(struct_name, "Payment");
            assert!(missing_fields.contains(&"processed_at".to_string()));
        } else {
            panic!("Expected MissingRequiredField error");
        }
    }

    #[test]
    fn test_check_error_display() {
        // Test new error display formats
        let err = CheckError::field_not_found("Payment", "created_at", vec!["amount".into()]);
        let msg = format!("{}", err);
        assert!(msg.contains("field `created_at` not found"));
        assert!(msg.contains("Payment"));
        assert!(msg.contains("amount"));

        let err = CheckError::method_not_found("OrderId", "as_u64", vec!["new".into()]);
        let msg = format!("{}", err);
        assert!(msg.contains("method `as_u64` not found"));

        let err = CheckError::variant_not_found("Status", "Inactive", vec!["Active".into()]);
        let msg = format!("{}", err);
        assert!(msg.contains("variant `Inactive` not found"));

        let err = CheckError::missing_fields("User", vec!["status".into(), "email".into()]);
        let msg = format!("{}", err);
        assert!(msg.contains("missing required field"));
        assert!(msg.contains("status"));

        let err = CheckError::arg_count_mismatch("new", 0, 1);
        let msg = format!("{}", err);
        assert!(msg.contains("expects 0 argument"));
        assert!(msg.contains("1 provided"));
    }
}