Features

This page provides an overview of the language server features that JETLS offers.

Screenshots on this page use VSCode (via the jetls-client extension), as its LSP UI is the de facto reference. The same features work in any supported editor, though the presentation may differ.^[error_lens]

Overview

• Diagnostic
• • Syntax diagnostics
  • Lowering diagnostics
  • Inference diagnostics
• Completion
• • Global and local completion
  • Method signature completion
  • Keyword argument completion
  • LaTeX and emoji completion
• Signature help
• Go to definition
• Document link
• Find references
• Hover
• Document highlight
• Document and workspace symbol
• Code lens
• • Reference count
  • TestRunner code lens
• Inlay hint
• Rename
• Code actions
• Formatting
• TestRunner integration
• Notebook support

Diagnostic

JETLS reports diagnostics from three analysis stages — syntax parsing, lowering, and type inference — covering everything from malformed input to deep type-level issues. Some diagnostics come with quick-fix code actions. See the Diagnostic reference for the full list of diagnostic codes and examples.

Syntax diagnostics

Parse errors detected by JuliaSyntax.jl.

Lowering diagnostics

Static analysis issues produced during lowering by JuliaLowering.jl — including undefined / unused bindings, unreachable code, scope ambiguities, and import-related issues.

Inference diagnostics

Type-level issues caught by JET.jl during type inference, such as non-existent field access, out-of-bounds indexing, method errors, and non-boolean conditions.

Completion

JETLS provides type-aware code completion with multiple modes.

Global and local completion

Completion for global symbols (functions, types, modules, constants) and local bindings. Global completion items include detailed kind information resolved lazily when a candidate is selected.

Method signature completion

Triggered inside a function call (after (, ,, or space). Compatible method signatures are suggested based on already-provided arguments. Selecting a candidate inserts remaining positional arguments as snippet placeholders with type annotations. Inferred return type and documentation are resolved lazily.

See [completion.method_signature] prepend_inference_result for the configuration option that shows the inferred return type inline.

Keyword argument completion

Triggered inside a function call at the keyword argument position (e.g. func(; |) or func(k|)). Available keyword arguments are suggested with = appended. Already-specified keywords are excluded.

LaTeX and emoji completion

Type \ to trigger LaTeX symbol completion (e.g. \alpha → α) or \: to trigger emoji completion (e.g. \:smile: → 😄), mirroring the Julia REPL.

Signature help

Method signatures are displayed as you type function arguments. Methods are filtered based on the inferred types of already-provided arguments — e.g., typing sin(1, shows only methods compatible with an Int first argument.

Go to definition

Jump to where a symbol is defined. JETLS resolves method and module definitions, as well as local bindings.

JETLS also implements go to declaration (textDocument/declaration), which jumps to declaration sites (e.g., import/using, local x, or empty function foo end) when distinct from the definition, and falls back to go to definition otherwise.

Document link

Path strings inside include("...") and include_dependency("...") calls become clickable links that open the referenced file. The path must be a single non-interpolated string and resolve to an existing file relative to the current document's directory.

Find references

Find all references to a symbol across files analyzed together (e.g., a package and its included files). Both local and global bindings are supported. When the client requests includeDeclaration=false, method definitions of the target are excluded.

Hover

Hover over symbols to see documentation and source locations.

Document highlight

Highlight all occurrences of the symbol at the cursor within the current file, distinguishing between writes (definitions, assignments) and reads (uses).

Document and workspace symbol

Code lens

JETLS surfaces actionable information inline above relevant code via code lenses.

Reference count

When code_lens.references is enabled, a reference count is displayed above each top-level symbol (functions, structs, constants, abstract/primitive types, modules). Clicking the lens dispatches the editor.action.showReferences command (a VSCode convention) carrying the pre-resolved reference locations. Clients that follow this convention open the references panel out of the box; clients that don't need a client-side handler — see the Neovim setup for an example.

TestRunner code lens

Run and re-run @testset blocks directly from the editor. See TestRunner code lens for details.

Inlay hint

Show inline annotations in the editor without modifying the source. JETLS currently supports block-end hints that label the construct a long end keyword closes. See [inlay_hint] block_end_min_lines for the threshold configuration.

Rename

Rename local or global bindings across files analyzed together (e.g., a package and its included files).

When renaming a string literal that refers to a file path (e.g. in include("foo.jl")), JETLS also renames the file on disk.

Code actions

JETLS provides code actions for quick fixes and refactoring, including:

• Prefix unused variables with _ (or delete the assignment entirely)
• Remove unused imports
• Sort import names
• Delete unreachable code
• Insert global / local declarations for ambiguous soft scope variables
• Run a nearby @testset or @test case via TestRunner code actions

A few representative examples:

Formatting

JETLS integrates with external formatters (Runic.jl by default, or JuliaFormatter.jl) for both document and range formatting. See Formatter integration for setup instructions.

TestRunner integration

Run individual @testset blocks and @test cases directly from the editor via code lenses and code actions, with results surfaced as inline diagnostics and logs. See TestRunner integration for setup and supported patterns.

Notebook support

JETLS provides LSP features for Julia code cells in Jupyter notebooks. Cells are analyzed together, so all LSP features including diagnostics, go-to definition, find-references, etc., work across cells. See Notebook support for details.