golang/vscode-go

Features

• Go Development Tooling - Provides a comprehensive development environment for Go with autocompletion, semantic highlighting, and automated formatting.
• Breakpoint Managers - Provides interfaces for configuring and managing execution breakpoints based on expressions or hit counts.
• Call Stack Navigators - Enables navigation through active stack frames and execution paths to inspect variable scopes.
• Toolchain Binary Installers - Downloads and updates required Go language tools and binaries directly into specified directories.
• Delve Integration - Implements a debugger interface that allows executing and inspecting Go programs via Delve.
• Debugger Protocol Integrations - Implements the Debug Adapter Protocol to standardize communication between the editor and the Go debugger.
• Editor Language Extensions - Acts as a VS Code extension providing deep Go language support through a language server.
• External Binary Lifecycle Managers - Manages the downloading and lifecycle of Go compiler and analysis binaries to ensure consistent tool versioning.
• Go Debugging Utilities - Provides a full suite of interactive debugging capabilities including breakpoints, call stack analysis, and state inspection.
• Go Module Dependencies - Enables tidying module files, upgrading dependencies, and updating vendor directories via inline actions.
• Linter Integrations - Integrates external linting tools to provide real-time coding style feedback and suggestions.
• Interactive Program Debugging - Provides an interactive environment to run programs, step through code, and identify logic errors.
• Language Server Clients - Implements the client-side logic to connect the editor to the Go language server for semantic analysis.
• Language Server Protocols - Uses the Language Server Protocol to exchange structured messages for navigation, completion, and diagnostics.
• Real-Time Code Diagnostics - Provides immediate visual feedback on syntax errors, warnings, and type mismatches directly within the editor.
• Static Code Linting - Integrates configurable linting tools to analyze source code for style violations and common programming mistakes.
• Symbol Searchers - Go extension capability to find symbols within the current file or across the entire workspace.
• Go Module Organization - Allows initializing new module files in the workspace and fetching specific packages from remote sources.
• Go Dependency Managers - Manages Go modules and tidies dependencies while scanning third-party packages for security vulnerabilities.
• Static Analysis Tools - Integrates linters and vetting tools to provide real-time diagnostics and enforce coding styles within the editor.
• Program State Inspection - Provides capabilities to view, modify, and track variables and expressions using a watch list during execution.
• DAP Debug Sessions - Launches interactive debugging sessions for main packages or precompiled binaries using the Debug Adapter Protocol.
• Toolchain Managers - Manages the installation and switching of different Go language versions using available SDKs.
• Source Code Formatting - Standardizes code style and organizes imports automatically during the save process.
• Process Attachment Tools - Connects the debugger to a running local process or an existing remote session.
• Unit Testing - Go extension capability to execute tests at the cursor, within a file, or across the entire workspace.
• Static Code Analysis - Runs analysis passes to detect unreachable code, unused variables, and non-idiomatic patterns without executing the program.
• Test and Benchmark Execution - Go extension capability to execute or debug individual tests and benchmarks using clickable code lens actions inside the source code.
• Unit Testing and Code Coverage - Executes unit tests and benchmarks with integrated code coverage visualization and boilerplate generation.
• Remote Debugging - Connects to a debugger server on a different machine or container to manage remote processes.
• Automated Code Refactoring - Go extension capability to perform automated transformations for code blocks, such as filling struct literals with default values.
• Document Outline Navigation - Displays a hierarchical list of all symbols in the current file for easier navigation.
• Function Signature Overlays - Displays function parameter and return type information in popups during code entry.
• Language-Specific Configurations - Enables overriding default toolchain binaries, debuggers, and language servers with custom paths.
• Logpoints - Records interpolated expressions to the debug console without pausing program execution.
• Language-Specific Environment Configuration - Allows adjusting binary versions, modifying workspace environment variables, and restarting the language server.
• Source Path Mapping - Translates between symlinked and physical file paths to ensure breakpoints and diagnostics align with source code.
• Inlay Hints - Renders inline visual cues to display parameter names and type information within the source code.
• Source and Test Toggling - Enables instant switching of the editor view between a source file and its matching unit test file.
• Interface Implementation Stubs - Creates required method signatures to implement a specific interface at the current cursor position.
• Symbol Navigation - Allows jumping from a symbol usage to its declaration and locating all references throughout the project.
• Hover Information Displays - Go extension capability to display documentation for a symbol when the user hovers over it with the cursor.
• Test File Navigation - Provides the ability to jump between source files and corresponding test files or open variable definitions.
• Implementation Search - Identifies all concrete types that implement a specific interface through static analysis.
• Background Process Execution - Runs external shell commands and build tools in background processes to prevent the user interface from freezing.
• Semantic Syntax Highlighting - Colors code elements based on semantic meaning from the language server to distinguish generics and advanced features.
• Automated Refactoring Tools - Go extension capability to perform symbol navigation and automated refactorings powered by a language server.
• Symbol Renamers - Go extension capability to update all occurrences of a symbol across the workspace to a new name.
• Package Renamers - Go extension capability to perform rename operations on packages and move associated subdirectories.
• Static Analysis Reports - Surfaces compile errors, type mismatches, and vetting results as real-time diagnostic reports in the editor.
• Code Coverage Analysis - Go extension capability to calculate and show the percentage of code exercised by tests within the current package.
• Visual Coverage Mapping - Go extension capability to run coverage analysis and visualize results via line highlights or gutter decorators during tests.
• On-Save Verification - Automatically executes static analysis and verification tools across files and packages whenever a file is saved.
• Performance Profiling - Go extension capability to collect and visualize CPU, memory, and mutex profiles to identify execution bottlenecks.
• Benchmark Executions - Go extension capability to execute all performance benchmarks within the current file or package to measure execution speed.
• Unit Test Boilerplate Generations - Go extension capability to create boilerplate test functions for existing code to accelerate unit test writing.
• Code Autocomplete Engines - Provides context-aware suggestions for symbols and packages as the user types.
• Semantic Highlighters - Applies visual styling to code based on the semantic meaning of symbols provided by the language server.
• Editor Plugins - Official Go extension for Visual Studio Code.

Historial de estrellas