Installing the command-line executable

Assuming you have Rust/Cargo installed, run this command in a terminal:

cargo install typescript-language-server

It will make the typescript-language-server command available in your PATH if you've allowed the PATH to be modified when installing Rust. cargo uninstall typescript-language-server uninstalls.

Back to the crate overview.

Readme

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

Feature	Status	Description
Document Symbols	✅	Outline view with functions, classes, variables
Semantic Tokens	✅	Rich syntax highlighting
Diagnostics	✅	Syntax errors and type diagnostics
Hover	✅	Type information and JSDoc comments
Folding Ranges	✅	Collapse functions, classes, imports
Selection Range	✅	Smart expand/shrink selection
Go to Definition	✅	Navigate to symbol definitions
Find References	✅	Find all usages of a symbol
Rename Symbol	✅	Rename across scope
Completions	✅	IntelliSense with built-ins and scope
Signature Help	✅	Function parameter hints
Inlay Hints	✅	Type and parameter annotations
Code Actions	✅	Quick fixes and refactorings

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

Open the editors/vscode folder in VSCode
Run pnpm install to install dependencies
Press F5 to launch the Extension Development Host
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.

Fork the repository
Create your feature branch (git checkout -b feature/amazing-feature)
Commit your changes (git commit -m 'Add some amazing feature')
Push to the branch (git push origin feature/amazing-feature)
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