A high-performance Language Server Protocol implementation for the VScript programming language, built in Rust.

• 🚀 Fast and Reliable: Built in Rust for maximum performance
• 🎯 Go-to Definition: Navigate to symbol definitions across files
• 💡 Intelligent Completion: Context-aware code completion
• 🔍 Hover Information: Rich type and documentation information
• 🚨 Real-time Diagnostics: Syntax and semantic error detection
• 🎨 Semantic Highlighting: Advanced syntax highlighting
• 📁 Workspace Management: Full project and module support
• 🔄 Module Resolution: Smart import resolution with v.mod support

# Clone the repository
git clone https://github.com/vscript/vscript-lsp.git
cd vscript-lsp

# Build the LSP server
cargo build --release

# The binary will be available at target/release/vscript-lsp

cargo install vscript-lsp

Start the LSP server:

vscript-lsp

The server communicates via stdin/stdout using the Language Server Protocol.

The LSP server is designed to work with any editor that supports LSP. See the Zed extension for a complete integration example.

For editors that support LSP, configure them to run vscript-lsp for .vs files.

Example configuration for various editors:

VS Code (settings.json):

{
  "vscript.lsp.serverPath": "vscript-lsp"
}

Vim/Neovim with coc.nvim:

{
  "languageserver": {
    "vscript": {
      "command": "vscript-lsp",
      "filetypes": ["vscript"]
    }
  }
}

The LSP server supports configuration through workspace settings:

{
  "vscript": {
    "diagnostics": {
      "enable": true,
      "unusedVariables": "warning"
    },
    "completion": {
      "enable": true,
      "autoImport": true
    },
    "hover": {
      "enable": true,
      "showDocumentation": true
    }
  }
}

• ✅ Functions and methods
• ✅ Classes and inheritance
• ✅ Variables and parameters
• ✅ Control flow (if/else, loops)
• ✅ Arrays and objects
• ✅ String interpolation
• ✅ Async/await
• ✅ Decorators (@[decorator])
• ✅ Imports and exports
• ✅ Try/catch blocks

The LSP understands VScript's module system:

// Import core modules
import core:os as os
import core:json as json

// Import local files
import "./utils.vs" as utils

// Module resolution follows v.mod files

The LSP provides hover information and completion for built-in functions:

• print(), println() - Output functions
• len(), push(), pop() - Collection functions
• to_string(), to_number() - Conversion functions
• Array methods: map(), filter(), reduce(), forEach()
• String methods: split(), replace(), trim()
• And many more...

The VScript LSP is structured as follows:

src/
├── main.rs          # LSP server entry point
├── analyzer.rs      # Semantic analysis engine
├── completion.rs    # Code completion provider
├── diagnostics.rs   # Error and warning detection
├── goto_definition.rs # Go-to-definition implementation
├── hover.rs         # Hover information provider
├── lexer.rs         # VScript tokenizer
├── parser.rs        # VScript parser and AST
└── workspace.rs     # Workspace and project management

• Lexer: Fast tokenization of VScript source code
• Parser: Builds Abstract Syntax Trees (AST) from tokens
• Analyzer: Performs semantic analysis and symbol resolution
• Workspace Manager: Handles project files and v.mod resolution

cargo build

cargo test

Enable debug logging:

RUST_LOG=debug vscript-lsp

1. Fork the repository
2. Create a feature branch (git checkout -b feature/amazing-feature)
3. Make your changes
4. Add tests for your changes
5. Run tests (cargo test)
6. Commit your changes (git commit -am 'Add amazing feature')
7. Push to the branch (git push origin feature/amazing-feature)
8. Open a Pull Request

This LSP server implements the following LSP features:

• textDocument/completion - Code completion
• textDocument/hover - Hover information
• textDocument/definition - Go to definition
• textDocument/references - Find references
• textDocument/documentSymbol - Document outline
• workspace/symbol - Workspace symbol search
• textDocument/publishDiagnostics - Error reporting
• textDocument/semanticTokens - Semantic highlighting

The VScript LSP is designed for performance:

• Fast Parsing: Incremental parsing with error recovery
• Efficient Memory Usage: Smart caching and cleanup
• Concurrent Analysis: Multi-threaded semantic analysis
• Lazy Loading: On-demand file processing

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

• VScript Compiler - The main VScript compiler
• Zed VScript Extension - Zed editor integration
• Tree-sitter VScript - Syntax highlighting grammar

• 📖 Documentation
• 🐛 Issue Tracker
• 💬 Discussions