wootype 0.2.1

Blazing-fast Go type system service —— Vibe Coding toolchain
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

//! Integration tests for:
//! 1. Go Modules complete support
//! 2. Cross-package code navigation
//! 3. Incremental update optimization

use std::collections::HashSet;
use std::sync::Arc;
use wootype::core::{CrossPackageIndex, CrossPackageNavigator, ModuleResolver, SymbolId};
use wootype::salsa_full::{ChangeSet, ChangeType, DependencyGraph, IncrementalProcessor};

// ===== Feature 1: Go Modules Tests =====

#[test]
fn test_stdlib_detection() {
    let resolver = ModuleResolver::new();

    // Standard library packages should be detected
    assert!(resolver.resolve_import("fmt").is_some());
    assert!(resolver.resolve_import("net/http").is_some());
    assert!(resolver.resolve_import("context").is_some());
    assert!(resolver.resolve_import("os/exec").is_some());
}

#[test]
fn test_non_stdlib_not_resolved() {
    let resolver = ModuleResolver::new();

    // External packages should not be resolved without go.mod
    assert!(resolver.resolve_import("github.com/foo/bar").is_none());
    assert!(resolver.resolve_import("example.com/mymodule").is_none());
}

#[test]
fn test_module_resolver_creation() {
    let resolver = ModuleResolver::new();
    assert!(resolver.module_path().is_none()); // No go.mod loaded
}

// ===== Feature 2: Cross-package Navigation Tests =====

#[test]
fn test_cross_package_index_creation() {
    let index = CrossPackageIndex::new();
    // Should create without panic
    let packages = index.all_packages();
    assert_eq!(packages.len(), 0);
}

#[test]
fn test_symbol_registration_and_lookup() {
    use wootype::core::xpackage::SymbolLocation;

    let index = CrossPackageIndex::new();
    let symbol = SymbolId::new(1);
    let location = SymbolLocation {
        package: Arc::from("test/package"),
        file: std::path::PathBuf::from("/test/file.go"),
        line: 10,
        column: 5,
    };

    index.register_symbol(symbol, location.clone());

    let found = index.find_definition(symbol);
    assert!(found.is_some());
    assert_eq!(found.unwrap().line, 10);
}

#[test]
fn test_cross_package_navigator() {
    use wootype::core::xpackage::SymbolLocation;

    let index = Arc::new(CrossPackageIndex::new());
    let navigator = CrossPackageNavigator::new(index.clone());

    let symbol = SymbolId::new(42);
    let location = SymbolLocation {
        package: Arc::from("github.com/example/lib"),
        file: std::path::PathBuf::from("/project/lib/helper.go"),
        line: 25,
        column: 1,
    };

    index.register_symbol(symbol, location);

    let result = navigator.goto_definition(symbol);
    assert!(result.is_some());
    assert_eq!(result.unwrap().line, 25);
}

// ===== Feature 3: Incremental Update Tests =====

#[test]
fn test_dependency_graph_creation() {
    let _graph = DependencyGraph::new();
    // Should create without panic
}

#[test]
fn test_dependency_registration() {
    let graph = DependencyGraph::new();
    let file = std::path::PathBuf::from("/test/main.go");

    graph.register_symbol(&file, "MyFunc".to_string());

    // Register dependency
    let dep_file = std::path::PathBuf::from("/test/other.go");
    graph.add_dependency(&dep_file, "MyFunc");
}

#[test]
fn test_affected_files_computation() {
    let graph = DependencyGraph::new();

    let changed_file = std::path::PathBuf::from("/test/changed.go");
    let mut changes = ChangeSet {
        changed_files: HashSet::new(),
        changed_symbols: HashSet::new(),
        change_type: ChangeType::FileContent,
    };
    changes.changed_files.insert(changed_file);

    let affected = graph.affected_files(&changes);
    assert!(affected.contains(&std::path::PathBuf::from("/test/changed.go")));
}

#[test]
fn test_incremental_processor_creation() {
    let graph = Arc::new(DependencyGraph::new());
    let _processor = IncrementalProcessor::new(graph);
    // Should create without panic
}