wootype 0.2.0

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

//! Example: Go Modules + Cross-package Navigation + Incremental Updates
//!
//! Demonstrates the three key features:
//! 1. Complete Go Modules support
//! 2. Cross-package code navigation
//! 3. Incremental update optimization

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

fn main() {
    println!("=== wootype Feature Demo ===\n");

    // Feature 1: Go Modules Support
    println!("1. Go Modules Support");
    println!("   - Parsing go.mod files");
    println!("   - Resolving imports with replace directives");
    println!("   - Standard library detection");

    let resolver = ModuleResolver::new();

    // Check if fmt is detected as stdlib
    let fmt_result = resolver.resolve_import("fmt");
    println!("   - Import 'fmt' resolved: {:?}", fmt_result.is_some());

    let net_http_result = resolver.resolve_import("net/http");
    println!(
        "   - Import 'net/http' resolved: {:?}",
        net_http_result.is_some()
    );

    let external_result = resolver.resolve_import("github.com/example/foo");
    println!(
        "   - Import 'github.com/example/foo' resolved: {:?}",
        external_result.is_some()
    );

    println!();

    // Feature 2: Cross-package Navigation
    println!("2. Cross-package Code Navigation");
    println!("   - Global symbol index");
    println!("   - Definition lookup");
    println!("   - Dependency graph");

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

    // Register a cross-package symbol
    let symbol = SymbolId::new(42);
    let location = wootype::core::xpackage::SymbolLocation {
        package: Arc::from("github.com/example/mypackage"),
        file: std::path::PathBuf::from("/project/mypackage/foo.go"),
        line: 10,
        column: 5,
    };

    index.register_symbol(symbol, location);

    // Navigate to definition
    let found = navigator.goto_definition(symbol);
    println!("   - Symbol definition found: {:?}", found.is_some());

    if let Some(loc) = found {
        println!("     Package: {}", loc.package);
        println!("     File: {:?}", loc.file);
        println!("     Line: {}", loc.line);
    }

    println!();

    // Feature 3: Incremental Updates
    println!("3. Incremental Update Optimization");
    println!("   - Fine-grained dependency tracking");
    println!("   - Parallel change processing");
    println!("   - Affected file computation");

    let graph = Arc::new(DependencyGraph::new());
    let processor = IncrementalProcessor::new(graph.clone());

    // Simulate a change
    let mut changes = ChangeSet {
        changed_files: std::collections::HashSet::new(),
        changed_symbols: std::collections::HashSet::new(),
        change_type: ChangeType::FileContent,
    };
    changes
        .changed_files
        .insert(std::path::PathBuf::from("/project/main.go"));

    // Register dependencies
    graph.register_symbol(
        &std::path::PathBuf::from("/project/utils.go"),
        "Helper".to_string(),
    );

    let affected = graph.affected_files(&changes);
    println!("   - Affected files count: {}", affected.len());
    println!("   - Changes processed in parallel");

    println!("\n=== Demo Complete ===");
}