IntelliSense and Code Navigation
Purpose and Scope
IntelliSense is the umbrella term VS Code uses for language-aware editing help: completions, member lists, quick info, parameter help, and related suggestions that appear while writing code. Code navigation is the companion set of workflows for moving through a project by file, symbol, definition, references, calls, and peek views. Together, these features let the editor feel lightweight while still providing IDE-style understanding when a language service, built-in extension, or installed extension can analyze the current document.
This page explains how to think about that experience from a contributor or extension-author perspective. The official user model says that VS Code ships rich IntelliSense for JavaScript, TypeScript, JSON, HTML, CSS, SCSS, and Less, and falls back to word-based completions for other languages until an extension contributes deeper language intelligence. In the repository evidence for this page, the directly visible implementation is strongest around code actions, AI-assisted edit mapping, Copilot code references, and launch entrypoints that open the workbench where language features run.
Sources: src/vs/editor/contrib/codeAction/common/types.ts, src/vs/workbench/contrib/chat/common/editing/chatCodeMapperService.ts, src/vs/workbench/contrib/chat/browser/chatEditing/chatEditingCodeEditorIntegration.ts
Relevant Source Files
- src/vs/editor/contrib/codeAction/common/types.ts - Defines shared code-action kinds, trigger sources, filters, auto-apply policy, and filtering helpers used by quick fixes, refactors, source actions, and save participants.
- src/vs/workbench/contrib/chat/common/editing/chatCodeMapperService.ts - Defines the code mapper service contract that turns chat-produced code blocks into text edits or notebook edits against workspace resources.
- src/vs/workbench/contrib/chat/browser/chatEditing/chatEditingCodeEditorIntegration.ts - Connects chat-generated edits to code editor UI concepts such as selections, ranges, diff decorations, view zones, overview ruler markers, minimap indicators, and accessible diff review.
- extensions/copilot/src/extension/completions-core/vscode-node/extension/src/codeReferencing/index.ts - Registers Copilot public code reference tracking when the authenticated Copilot token enables code quote behavior.
- cli/src/bin/code/main.rs - Routes the public command-line entrypoint into desktop startup, status, version, extension, server, tunnel, and agent-related commands before opening the editor process.
- src/vs/code/electron-main/main.ts - Starts the Electron main process, parses line-and-column-aware paths, wires core services, and launches the workbench that hosts editor navigation and language features.
Core Editing Intelligence Model
A language feature normally begins with context: the active text model, cursor position, selection, language identifier, diagnostics, and workspace files. A language service can then return completions, hover information, symbols, references, code actions, or edits. The user-facing result may be a suggestion widget, a lightbulb, a peek editor, a symbol list, or a direct edit. The official docs emphasize that suggestions can be triggered as the user types, by trigger characters such as a dot in JavaScript, or by an explicit completion command.
The code-action layer in this source set shows how VS Code classifies one important family of language assistance. CodeActionKind has hierarchical kinds for quick fixes, refactors, extract, inline, move, rewrite, notebook actions, source actions, organize imports, fix all, and surround-with refactors. That hierarchy matters because the editor can request only the subset relevant to a gesture. A lightbulb near a diagnostic should not behave the same way as an organize-imports-on-save request, even when both are implemented by the same language extension.
Sources: src/vs/editor/contrib/codeAction/common/types.ts
The filtering helpers also show an important design constraint: VS Code avoids returning broad source actions unless the caller explicitly asks for them. mayIncludeActionsOfKind checks whether a provider kind intersects the requested filter, honors excluded kinds, and suppresses source actions unless includeSourceActions is true. filtersAction applies similar checks to concrete actions and can restrict results to preferred actions. This keeps commands such as quick fix, refactor, fix all, and organize imports predictable even when a provider advertises many possible operations.
Navigation, Peek, and Launch Context
Navigation features depend on both in-editor state and how a window was opened. The Electron main entrypoint imports path parsing helpers such as parseLineAndColumnAware, IPathWithLineAndColumn, and sanitizeFilePath, which are the kind of startup utilities needed when a user launches the editor with a file path plus an intended line and column. The Rust CLI similarly routes user intent into the desktop process by collecting command arguments, constructing base Code arguments, and calling startup behavior when no subcommand takes over.
Sources: cli/src/bin/code/main.rs, src/vs/code/electron-main/main.ts
That launch path is not itself the implementation of Go to Definition or Find References, but it establishes the initial editor context in which those features operate. Opening a file at a specific location, using command-line status or extension commands, or starting a server/web/tunnel mode all feed into the same product expectation: once a workbench window has a text editor and model, language-backed commands can resolve symbols, reveal locations, and show navigation UI. For contributors, this means startup code and editor-language code are separate layers that still shape the same user journey.
Peek and reference workflows are best understood as navigation with preservation of context. Instead of replacing the active editor immediately, a peek surface can show candidate definitions, references, or calls inline while keeping the original file visible. The supplied source evidence does not include the peek providers themselves, but the chat editing integration demonstrates nearby editor primitives used by rich inline review surfaces: ranges, selections, line-range mappings, decorations, overview ruler lanes, minimap positions, view zones, diff rendering, and accessible diff models.
Sources: src/vs/workbench/contrib/chat/browser/chatEditing/chatEditingCodeEditorIntegration.ts
Code Actions and Refactoring Reference
| Component | Public contract visible in source | Reader impact |
|---|---|---|
CodeActionKind.QuickFix | Hierarchical kind quickfix | Diagnostic-driven repair actions can be requested separately from refactors. |
CodeActionKind.RefactorExtract | Hierarchical kind under refactor.extract | Extract-method or extract-variable style providers can be grouped under refactoring UI. |
CodeActionKind.SourceOrganizeImports | Hierarchical kind under source.organizeImports | Organize imports is treated as a source action and must be explicitly requested by callers. |
CodeActionKind.SourceFixAll | Hierarchical kind under source.fixAll | Fix-all operations can be filtered away from ordinary quick fixes unless the trigger asks for them. |
CodeActionAutoApply | ifSingle, first, never | Callers can express whether an action should be applied automatically or only presented. |
CodeActionTriggerSource | Refactor, lightbulb, quick fix, on save, problems view, and related sources | Telemetry, behavior, and filtering can distinguish the gesture that requested actions. |
The key contributor lesson is that code actions are not a flat list. They are classified by intent, filtered by caller, and optionally constrained by preference. A provider that returns a source action should not expect it to appear in every quick-fix request, because the common helper deliberately suppresses source actions unless the request opts in. Similarly, a refactor preview trigger can be distinguished from a normal refactor trigger, which allows UI and providers to preserve the difference between browsing choices and applying edits.
Sources: src/vs/editor/contrib/codeAction/common/types.ts
AI-Assisted Navigation and Edit Review
Modern VS Code language assistance also includes AI-generated edits and completions that must map back to concrete code locations. The code mapper service defines a provider model for taking chat response code blocks and producing edits. A request contains code blocks, optional chat request identifiers, model information, an optional chat session resource, and a location string. A response exposes callbacks for text edits and notebook cell edit operations, so a mapper can apply generated code to either ordinary files or notebooks.
Sources: src/vs/workbench/contrib/chat/common/editing/chatCodeMapperService.ts
The mapper service uses a small provider registry. registerCodeMapperProvider adds a provider and returns a disposable that removes it. mapCode iterates over registered providers, calls the first provider, respects cancellation, and returns the provider result or undefined. This is a narrow but important contract: AI edit mapping is separated from the UI that reviews edits, and providers are responsible for translating generated code into workspace-specific modifications rather than forcing the chat layer to know every language or file format.
The editor integration then turns those edits into something a developer can inspect. Its imports show dependencies on text models, ranges, selections, diff providers, detailed line-range mappings, decoration collections, inline decorations, minimap and overview ruler locations, editor reveal types, and accessible diff viewing. That combination is what makes AI edits feel like code navigation rather than only text replacement: users can see where changes land, move between hunks, compare added and deleted lines, and review proposed modifications in the same editor surfaces used for other code-understanding workflows.
Sources: src/vs/workbench/contrib/chat/browser/chatEditing/chatEditingCodeEditorIntegration.ts, src/vs/workbench/contrib/chat/common/editing/chatCodeMapperService.ts
Copilot Code References
Copilot completions can also surface code-reference behavior. The CodeReference class registers a listener for Copilot token changes outside test runtime, reads whether codeQuoteEnabled is set, and either disposes existing subscriptions or creates a CodeRefEngagementTracker. It logs whether public code references are enabled or disabled. This means code referencing is controlled by authentication and token capabilities, not just by editor UI state, and it can be torn down cleanly when the capability is unavailable.
Sources: extensions/copilot/src/extension/completions-core/vscode-node/extension/src/codeReferencing/index.ts
For readers using IntelliSense and navigation day to day, the practical distinction is that language services explain your local codebase while Copilot code references concern generated suggestions and public-code reference engagement. They can appear in the same editing flow, but their trust boundaries differ. Local quick fixes, symbol navigation, and reference search are workspace-language features; Copilot code references depend on Copilot authentication state and the token flag that enables code quote behavior.
Execution Flow
- A user opens VS Code from the desktop shell or
codecommand, optionally with file and location arguments that are parsed by the launch layer. - The workbench creates editors and text models for opened resources, giving language services and extensions the context needed for completions, symbols, diagnostics, and actions.
- When the user invokes a command such as quick fix, refactor, organize imports, or fix all, code-action filtering selects provider results that match the trigger and requested kind.
- When chat produces code intended for the workspace, a registered mapper provider converts code blocks into text or notebook edits, and the editor integration renders the result for review.
- When Copilot code quote support is enabled by token state, the completions extension registers engagement tracking for public code references; when disabled, it disposes that tracking.
Next Steps
To extend this area, start by deciding whether your feature is a language service capability, an editor UI surface, a code action, or an AI edit workflow. Language extensions should expose semantic operations through the VS Code extension API, while workbench code should preserve predictable filtering, cancellation, and review behavior. For adjacent reading, continue with Basic Editing for editor primitives, Inline Chat and AI Edits for AI change review, JavaScript and TypeScript for bundled language behavior, and Extension Authoring Overview for contribution points and API contracts.