Delve is a full-featured debugger for the Go programming language. It provides a command-line interface (CLI) and supports integration with IDEs via the Debug Adapter Protocol (DAP). The debugger allows users to control program execution, inspect variables and memory, set breakpoints and watchpoints, examine stack traces and goroutines, and evaluate expressions. It supports multiple operating systems (Linux, Windows, macOS, FreeBSD) and architectures (amd64, arm64, ppc64le, riscv64, loong64) and includes advanced features such as eBPF-based tracing, reverse debugging via Mozilla rr, and core dump analysis. The architecture is modular, with clear abstractions for OS-specific, architecture-specific, and backend-specific code, enabling maintainability and extensibility.
This repository is a production-grade Rust implementation of the Starlark language, the deterministic Python-like configuration language used by build systems such as Bazel and Buck2. The system is structured as a multi-crate workspace: `starlark` provides the core runtime (parser, bytecode compiler, evaluator, garbage-collected heap, type system, and standard library), `starlark_syntax` handles parsing and AST, `starlark_map` offers high-performance ordered hash maps and sets, `starlark_derive` supplies procedural macros for defining Starlark-compatible Rust types, and `starlark_bin` bundles a CLI with REPL, linter, and Debug Adapter Protocol (DAP) server. Additional crates include `starlark_lsp` for Language Server Protocol support and a WASM example for embedding in JavaScript. The architecture is a classic interpreter pipeline: source text is parsed into an AST (`AstModule`), compiled to bytecode (with optimizations like constant folding, speculative execution, and inlining), and executed by a stack-based bytecode VM. Values are managed on a two-tier heap (unfrozen mutable and frozen immutable) with a custom bump allocator and explicit freeze operations. The type system supports both runtime type checking and static analysis, including union types, callable signatures, and generic type matchers. External dependencies include the `tower-lsp` and `lsp-types` crates for the LSP server, and several internal Facebook crates (e.g., `buck2_core`, `buck2_data`) for pagable serialization and profiling. Key entry points are `starlark::eval::eval_module` for programmatic evaluation, `starlark_bin/bin/main.rs` for the CLI, and the `#[starlark_module]` and `#[starlark_value]` proc macros for extending the language with custom types and functions. The system is designed for embedding in build tools, with a focus on performance, determinism, and debuggability.
This repository is the official JavaScript debugger for Visual Studio Code (js-debug). It implements a full Debug Adapter Protocol (DAP) server that communicates with JavaScript runtimes via the Chrome DevTools Protocol (CDP). The debugger supports Node.js, Chrome, Edge, WebView2, VS Code extension hosts, Blazor, and WebAssembly (with DWARF symbols). The architecture is modular, with a core adapter layer handling breakpoints, source maps, evaluation, and console output; target-specific launchers for Node and browser processes; a UI layer providing VS Code commands, configuration providers, and profiling tools; and extensive telemetry and diagnostics infrastructure. Key entry points include the VS Code extension activation (`src/extension.ts`) and a standalone DAP server (`src/debugServerMain.ts`). The codebase uses dependency injection (Inversify), custom event emitters, and source map management with caching and rename support. External dependencies include `ws` (WebSocket), `got` (HTTP), `acorn`/`astring` (JavaScript parsing/code generation), and `@jridgewell/trace-mapping` (source map resolution). While primarily an application, it includes a diagnostic tool webview and telemetry for operational analysis.