TypeScript Language Server (Rust)

A high-performance Language Server Protocol (LSP) implementation for TypeScript and JavaScript, written in Rust.

Features

Language Support

• TypeScript (.ts)
• TypeScript React (.tsx)
• JavaScript (.js, .mjs, .cjs)
• JavaScript React (.jsx)

LSP Capabilities

Installation

From Source

# Clone the repository
git clone https://github.com/your-username/typescript-language-server.git
cd typescript-language-server

# Build the language server
cargo build --release

# The binary will be at target/release/typescript-language-server

VSCode Extension

cd editors/vscode
pnpm install
pnpm exec tsc

Then press F5 in VSCode to launch the extension development host.

Usage

Command Line

# Start the language server (communicates via stdio)
./target/release/typescript-language-server

With VSCode

1. Open the editors/vscode folder in VSCode
2. Run pnpm install to install dependencies
3. Press F5 to launch the Extension Development Host
4. Open any TypeScript or JavaScript file

With Other Editors

The language server uses standard LSP over stdio. Configure your editor's LSP client to run:

/path/to/typescript-language-server

Architecture

┌─────────────────────────────────────────────────────────┐
│                    LSP Server (tower-lsp)               │
└─────────────────────────────┬───────────────────────────┘
                              │
┌─────────────────────────────▼───────────────────────────┐
│                    Project System                        │
│              (tsconfig, file graph, workspace)           │
└─────────────────────────────┬───────────────────────────┘
                              │
┌─────────────────────────────▼───────────────────────────┐
│                    Type Checker                          │
│         (inference, narrowing, assignability)            │
└─────────────────────────────┬───────────────────────────┘
                              │
┌─────────────────────────────▼───────────────────────────┐
│                    Binder / Symbol Table                 │
│              (scopes, symbols, references)               │
└─────────────────────────────┬───────────────────────────┘
                              │
┌─────────────────────────────▼───────────────────────────┐
│                    Module Resolver                       │
│         (imports, node_modules, path mapping)            │
└─────────────────────────────┬───────────────────────────┘
                              │
┌─────────────────────────────▼───────────────────────────┐
│                    Parser (tree-sitter)                  │
│                    (AST, syntax tree)                    │
└─────────────────────────────────────────────────────────┘

Project Structure

typescript-language-server/
├── src/
│   ├── main.rs              # Entry point
│   ├── server.rs            # LSP server implementation
│   ├── document.rs          # Document management
│   ├── parser.rs            # tree-sitter parsing
│   ├── analysis/            # Symbol table & binder
│   │   ├── scope.rs         # Scope tree
│   │   ├── symbol.rs        # Symbol definitions
│   │   ├── symbol_table.rs  # Per-file symbol storage
│   │   └── binder.rs        # AST → symbols
│   ├── capabilities/        # LSP features
│   │   ├── completions.rs
│   │   ├── diagnostics.rs
│   │   ├── hover.rs
│   │   ├── definition.rs
│   │   └── ...
│   ├── resolution/          # Module resolution
│   │   ├── resolver.rs
│   │   ├── tsconfig.rs
│   │   └── node_modules.rs
│   ├── project/             # Project system
│   │   ├── project.rs
│   │   ├── file_graph.rs
│   │   └── workspace.rs
│   └── types/               # Type system
│       ├── types.rs         # Type representations
│       ├── checker.rs       # Type checker
│       └── printer.rs       # Type display
├── editors/
│   └── vscode/              # VSCode extension
├── benches/                 # Criterion benchmarks
└── benchmarks/              # LSP comparison benchmarks

Development

Prerequisites

• Rust 1.70+
• Node.js 18+
• pnpm (for VSCode extension)

Building

# Debug build
cargo build

# Release build
cargo build --release

# Run tests
cargo test

# Run with logging
RUST_LOG=debug cargo run

Testing

# Run all Rust tests
cargo test

# Run tests with output
cargo test -- --nocapture

# Run specific test
cargo test test_name

# Run VSCode extension tests
cd editors/vscode
pnpm test

Code Coverage

# Install cargo-llvm-cov
cargo install cargo-llvm-cov

# Generate coverage report
cargo llvm-cov --html

# View report
open target/llvm-cov/html/index.html

Benchmarks

# Run Rust benchmarks
cargo bench

# Run LSP comparison benchmarks
cd benchmarks
./run-benchmarks.sh

Configuration

The language server respects tsconfig.json / jsconfig.json files:

{
  "compilerOptions": {
    "target": "ES2020",
    "module": "ESNext",
    "moduleResolution": "bundler",
    "baseUrl": ".",
    "paths": {
      "@/*": ["src/*"]
    }
  },
  "include": ["src/**/*"],
  "exclude": ["node_modules"]
}

Supported Options

• compilerOptions.target
• compilerOptions.module
• compilerOptions.moduleResolution (node, node16, nodenext, bundler)
• compilerOptions.baseUrl
• compilerOptions.paths
• compilerOptions.strict and related flags
• include / exclude patterns
• extends for configuration inheritance

Performance

This implementation uses:

• tree-sitter for fast, incremental parsing
• DashMap for concurrent document storage
• tower-lsp for async LSP handling

Benchmarks show significant improvements over the official TypeScript language server for parsing and symbol resolution operations.

Contributing

Contributions are welcome! Please feel free to submit a Pull Request.

1. Fork the repository
2. Create your feature branch (git checkout -b feature/amazing-feature)
3. Commit your changes (git commit -m 'Add some amazing feature')
4. Push to the branch (git push origin feature/amazing-feature)
5. Open a Pull Request

Development Guidelines

• Run cargo fmt before committing
• Ensure cargo clippy passes
• Add tests for new features
• Update documentation as needed

License

This project is licensed under the MIT License - see the LICENSE file for details.

Acknowledgments

• tower-lsp - LSP server framework
• tree-sitter - Incremental parsing
• tree-sitter-typescript - TypeScript grammar
• TypeScript - Language specification reference