This repository provides a comprehensive VHDL language toolchain written in Rust, centered around a Language Server Protocol (LSP) implementation. It includes a lossless concrete syntax tree (CST) parser (`vhdl_syntax`), a semantic analysis library (`vhdl_lang`) with name resolution, type checking, and overload resolution, a standalone linter (`vhdl-lint`) with rule selection and auto-fix, a formatter, and a CLI for AST dumping. The architecture is modular, with separate crates for parsing, analysis, linting, and the LSP server, enabling reuse of components like the CST framework and diagnostic system. The codebase demonstrates high craftsmanship with extensive test coverage (including fuzzing and snapshot tests), code generation from a grammar model, and careful handling of VHDL's Latin-1 encoding and source positions. However, it suffers from a dual-parser architecture (the older hand-written parser in `vhdl_lang` coexists with the newer CST parser in `vhdl_syntax`), which introduces duplication and potential drift. Some VHDL-2019 features are partially supported, and the project tracks the latest Rust stable, imposing a high maintenance burden. Overall, it is a production-quality tool for VHDL developers, with several reusable components that could be extracted for other VHDL tooling projects.
This repository implements a Language Server Protocol (LSP) server for the Stimulus JavaScript framework, providing intelligent tooling for editors like VS Code. The architecture follows a standard client/server LSP pattern where the TypeScript-based VS Code extension (client) communicates with a TypeScript language server (server) via JSON-RPC. The server parses HTML, ERB, Blade, PHP, and JavaScript/TypeScript files to offer Stimulus-specific features: autocompletion for controllers/actions/targets, diagnostics for incorrect usage, code actions for quick fixes, and code navigation. Key capabilities include validating Stimulus controller existence, action correctness, and proper data attribute usage, with intelligent suggestions for corrections.
Dingo is a source-to-source transpiler for a custom language that extends Go with Rust-inspired features like sum types (enums), pattern matching, error propagation (`?`), safe navigation (`?.`), null coalescing (`??`), lambdas, tuples, and functional utilities (Option/Result). The transpiled output is clean, idiomatic Go with zero runtime overhead. The repository includes a full CLI tool (`dingo`) with build, run, fmt, lint, and update commands, as well as a language server (`dingo-lsp`) that wraps gopls as a proxy and uses source maps (`.dmap` binary format) for position translation. Editor integrations cover VS Code, Neovim, and JetBrains. The codebase is organized as a monolith with a modular plugin architecture for AST transformations. While actively developed and containing several well-crafted reusable components (source map binary format, error formatting with carets and suggestions, concurrent type cache, animated terminal mascot), the project shows signs of architectural fragmentation: duplicate parser implementations, a legacy preprocessor coexisting with a newer AST pipeline, multiple skipped tests, and known incomplete features tracked in TODOs. The scope is ambitious — many language features are implemented but the overall coherence suffers from incremental AI-assisted development patterns visible in the extensive ai-docs archive.
This is a Visual Studio Code extension providing comprehensive language support for Garry's Mod Lua (GLua). It delivers syntax highlighting, autocompletion, hover documentation, signature help, go-to-definition, find references, color picker, type hints, file previews (VTF/PNG), workspace scanning, global variable optimization, and a bytecode heatmap generator. The extension is built as a single Node.js process using the VS Code API, with a custom Lua parser (gluaparse) for AST analysis and a bundled gluac binary for LuaJIT bytecode manipulation. It downloads wiki data from a remote server and caches it locally. The codebase is well-organized into providers and commands, but is tightly coupled to the VS Code extension model and Garry's Mod-specific data sources, limiting direct reuse outside this context. A Python-based generator script for scraping the Facepunch wiki is also included as a separate tool.
Prog8 is a Kotlin/JVM compiler and language toolchain for retro 8-bit/16-bit platforms (C64, C128, CX16, PET32, Amiga, m68k). It compiles a high-level language to 6502/68000 assembly through a multi-stage pipeline: lexer/parser, AST construction, semantic analysis, intermediate representation, optimizer, code generation, and optional VM execution. The repository also includes an LSP server, a Gradle build with Kotest tests, CI workflows, and target-specific runtime libraries. It is primarily an application (compiler/CLI), not a data/research project.
This is the idris2-lsp language server, a monolithic LSP server implementation for the Idris2 programming language. It provides standard IDE features such as go-to-definition, hover information, code completions, document symbols, semantic tokens, diagnostics, and various code actions including case splitting, expression search, and refactoring. It runs as a single process reading JSON-RPC messages from stdin and writing responses to stdout, leveraging the Idris2 compiler's API to load modules, resolve names, and perform type-checking. The server is built with Idris2 itself and depends on the lsp-lib library for LSP message types and encoding. While the codebase is well-crafted for its domain, it is tightly coupled to Idris2 internals and the LSP protocol, making it highly specific to the Idris ecosystem and not easily reusable outside that context.
This VS Code extension replaces the built-in TypeScript version with the nightly build of TypeScript (`typescript@next`), providing the latest TypeScript and JavaScript IntelliSense features. It is a small, focused extension that contributes TextMate grammars for JavaScript, TypeScript, JSX, and TSX syntax highlighting, sourced from the Microsoft/TypeScript-TmLanguage repository. The extension is designed for advanced users who want to test upcoming TypeScript features before they are officially released. The codebase is minimal: a package.json defining the extension, a set of grammar JSON files, and build scripts for updating the grammar and version. The CI pipeline (Azure Pipelines) automates the process of pulling the latest TypeScript nightly and publishing the extension. The extension is currently in a maintained state but with reduced activity, as the CI scheduled trigger is disabled to avoid picking up TypeScript 7. The grammars are large, well-structured TextMate definitions that follow standard patterns and are reusable in other editors. The overall codebase is functional and straightforward, but lacks original craftsmanship beyond the grammar modularity.