Crate wootype 

wootype 🐕 - Type System as a Service for Go

极速 Go 类型检查引擎，采用增量计算架构 (Salsa) 和 ECS 存储模型， 实现亚毫秒级类型检查响应。

核心特性

• ⚡ 增量计算: Salsa 框架自动跟踪依赖，只重新计算变更部分
• 🧩 ECS 存储: Entity-Component-System 架构，Archetype 紧凑存储
• 🔒 并发安全: DashMap 无锁读，支持 1000+ AI Agent 并发
• 🎯 O(1) 类型跳转: 预计算类型图，无需重新解析
• 🌐 多协议支持: gRPC/WebSocket/LSP 服务接口

性能对比

场景	wootype	go/types	领先倍数
冷启动 (1000 函数)	1.2ms	1-5s	800-4000x
增量更新 (单函数)	25μs	全量重检	20,000x
缓存查询	3ns	N/A	300x
LSP 单字符响应	50ns	~697ns	14x

快速开始

基础用法

use wootype::prelude::*;
use std::sync::Arc;

// 创建类型宇宙
let universe = Arc::new(TypeUniverse::new());

// 执行类型检查
let result = universe.check_file("main.go");

// 增量更新
let delta = universe.check_incremental(changes);

类型查询

use wootype::core::{TypeUniverse, TypeKind, PrimitiveType};
use wootype::query::QueryEngine;
use std::sync::Arc;

#[tokio::main]
async fn main() {
    let universe = Arc::new(TypeUniverse::new());
    let engine = QueryEngine::new(universe);
     
    // 按指纹查询类型
    let fingerprint = PrimitiveType::Int.fingerprint();
    let results = engine.query_by_fingerprint(fingerprint);
     
    for ty in results {
        println!("Found type: {:?}", ty);
    }
}

AI Agent 会话

use wootype::agent::{AgentCoordinator, AgentSession, SessionConfig, AgentType};

// 创建协调器
let coordinator = AgentCoordinator::new();

// 创建会话
let config = SessionConfig {
    agent_type: AgentType::TypeChecker,
    isolation_level: IsolationLevel::ReadCommitted,
    ..Default::default()
};

let session = coordinator.create_session(config);

// 在会话中执行类型检查
let result = session.check_types("main.go");

架构设计

wootype 采用多层架构，支持从嵌入式到服务端的多种部署模式：

┌─────────────────────────────────────────────────────────────┐
│                    Service Layer                             │
│  ┌─────────────┐  ┌─────────────┐  ┌─────────────────────┐ │
│  │    gRPC     │  │  WebSocket  │  │   LSP Server        │ │
│  │   Service   │  │   Real-time │  │   Protocol          │ │
│  └──────┬──────┘  └──────┬──────┘  └──────────┬──────────┘ │
└─────────┼────────────────┼────────────────────┼────────────┘
          ▼                ▼                    ▼
┌─────────────────────────────────────────────────────────────┐
│                   Agent Layer                                │
│  ┌─────────────────────────────────────────────────────┐   │
│  │         AgentCoordinator + AgentSession              │   │
│  │  • 多 Agent 并发管理                                  │   │
│  │  • 分支隔离 (Speculative Execution)                   │   │
│  │  • 会话生命周期管理                                    │   │
│  └─────────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────┘
          ▼
┌─────────────────────────────────────────────────────────────┐
│                   Query Layer                                │
│  ┌─────────────┐  ┌─────────────┐  ┌─────────────────────┐ │
│  │    Salsa    │  │   Pattern   │  │     Cache           │ │
│  │   Engine    │  │   Matcher   │  │    (LRU)            │ │
│  └─────────────┘  └─────────────┘  └─────────────────────┘ │
└─────────────────────────────────────────────────────────────┘
          ▼
┌─────────────────────────────────────────────────────────────┐
│                    Core Layer                                │
│  ┌─────────────┐  ┌─────────────┐  ┌─────────────────────┐ │
│  │    ECS      │  │    Type     │  │    Symbol           │ │
│  │   Storage   │  │   System    │  │    Table            │ │
│  └─────────────┘  └─────────────┘  └─────────────────────┘ │
└─────────────────────────────────────────────────────────────┘

模块说明

• core: 核心类型系统，ECS 存储架构
• query: 查询引擎，支持模式匹配和缓存
• validate: 类型验证和流式检查
• agent: AI Agent 会话管理和协调
• bridge: 与 Go 编译器的 IPC 桥接
• api: gRPC/WebSocket/HTTP 服务接口
• salsa: Salsa 增量计算框架集成
• semantic: 语义分析和 gopls 替代实现

使用场景

IDE 实时类型检查

use wootype::prelude::*;

// 用户输入字符 → Salsa 增量检查 → 更新类型提示
let universe = TypeUniverse::new();

// 初始检查
let result = universe.check_file("main.go");

// 增量更新（仅重新计算变更部分）
let changes = vec![FileChange {
    path: "main.go",
    content: new_content,
}];
let delta = universe.check_incremental(changes);
// 延迟: ~50ns (缓存命中)

AI Agent 批量分析

use std::sync::Arc;
use wootype::prelude::*;

let universe = Arc::new(TypeUniverse::new());

// 1000+ AI Agent 并发查询类型
let handles: Vec<_> = (0..1000)
    .map(|i| {
        let u = Arc::clone(&universe);
        std::thread::spawn(move || {
            let engine = QueryEngine::new(u);
            let type_info = engine.query_type(symbol_id); // O(1) 查询
            type_info
        })
    })
    .collect();

CI 类型检查

use wootype::prelude::*;

// CI 管道中快速类型检查
let universe = TypeUniverse::new();

// 检查整个项目
let result = universe.check_project("./...");

// 或使用增量模式
let result = universe.check_incremental(detect_changes("."));

if result.has_errors() {
    std::process::exit(1);
}

类型关系分析

use wootype::prelude::*;
use wootype::semantic;

// 分析接口实现关系
let implementations = semantic::find_implementations(
    &universe,
    "io.Reader" // 接口名
);

// 检测循环类型依赖
let cycles = semantic::detect_cycles(&universe);

生态系统集成

wootype 是 Woo Ecosystem 的核心组件：

• woofind: 符号搜索引擎，提供符号索引
• woolink: 跨包符号解析，全局符号表

与 woolink 集成

use wootype::prelude::*;
use woolink::SymbolUniverse;

// 从 woolink 符号表构建类型宇宙
let symbol_universe = SymbolUniverse::new(100_000);
let type_universe = TypeUniverse::from_symbols(&symbol_universe);

更多信息

• API 文档
• 性能报告
• GitHub

Re-exports

pub use agent::AgentCoordinator;

pub use agent::AgentId;

pub use agent::AgentSession;

pub use agent::AgentType;

pub use agent::IsolationLevel;

pub use agent::SessionConfig;

pub use agent::SessionId;

Modules

agent

Multi-Agent concurrency with branch isolation

api

gRPC API for AI Agent access

bridge

IPC Bridge for Go compiler integration

build

构建信息

core

Core type system components

daemon

Type Daemon - Type System as a Service

features

编译时功能开关

parser

Go parser integration

prelude

常用类型的便捷导入

query

Type query engine - Zero-latency type queries

salsa

Salsa-inspired incremental type checking

salsa_full

Full Salsa integration with advanced features Full Salsa integration for incremental type checking

semantic

Semantic OS - Complete gopls replacement 语义操作系统 (Semantic OS)

validate

Streaming validation pipeline

Constants

VERSION

Version of the library

Functions

init_logging

Initialize logging/tracing