VBA Runner — VS Code Extension

A VS Code extension for VBA development. When you open .bas / .cls / .frm files, rich editing support powered by LSP (Language Server Protocol) becomes available.

日本語 | CHANGELOG | VBA Runner Project | Documentation hub

Audience: package users. For goal-oriented guides, see the documentation hub.

Installation

Install from the VS Code Marketplace by searching for VBA Runner, or run:

code --install-extension jca02266.vba-runner

For development (when cloning the repository):

1. Open this repository in VS Code
2. Press F5 to launch the Extension Development Host
3. Open a .bas / .cls / .frm file in the new window

Supported File Types

Editor Support (LSP)

Hover

Hovering over a symbol (Sub / Function / variable / constant / class / event) shows its signature in a popup.

Sub CalcSum(a As Integer, b As Integer)
'         ↑ Hover here → "Sub CalcSum(a As Integer, b As Integer)"

Signature Help

When you type ( or , inside a function call, a popup shows the parameter names and the current parameter position. Works for built-in VBA functions (MsgBox, Format, etc.) as well as your own Sub / Function declarations.

Go to Definition

Place the cursor on a symbol and press F12 to jump to its declaration.

Find References

Place the cursor on a symbol and press Shift+F12 to list all locations where it is referenced.

Rename Symbol

Place the cursor on a symbol and press F2 to rename it across the file. All references are updated at once.

Code Completion

Suggestions for VBA keywords, built-in functions, and procedures defined in your source files appear as you type.

Member Completion (.)

Typing . after a variable shows members specific to its declared type. Supports:

Cross-module completion is also supported: classes declared in other open .bas / .cls files in the workspace are recognized automatically.

Chain Access Resolution

Member completion works across chained accesses. The return type of each member is tracked, so subsequent . completions resolve correctly:

Dim ws As Worksheet
ws.Cells.         ' → Range members (Cells returns Range)
ws.Range("A1").Offset(1, 0).  ' → Range members (Offset returns Range)
ws.Parent.        ' → Workbook members (Parent returns Workbook)

With Block Completion

Inside a With block, typing . at the start of a line shows the members of the With object:

With ws
    .Cells.       ' → Range members
    .Name         ' → "Name" property of Worksheet
End With

Snippets

Document Symbols (Outline)

The outline panel (Ctrl+Shift+O) and the workspace symbol search (Ctrl+T) list all Sub / Function / Property / class members defined in your VBA files.

Section divider comments using ' --- Name --- or ' === Name === are also recognized as Namespace symbols in the outline, making large modules easier to navigate.

' ─── Initialization ───────────────────────────────
Public Sub Initialize()
    ...
End Sub

' === Data Processing ===
Public Function Process(data) As Long
    ...
End Function

Diagnostics

The following diagnostic rules are reported as you type:

Host-dependent identifier recommendations include a GitHub link to the mock guide and a generic AI prompt for creating the smallest mock and a focused test. Diagnostics refresh immediately when __mocks__ files are created, edited, or deleted.

JavaScript mocks are not executed while diagnostics are calculated. Only statically discoverable names such as module.exports object properties are resolved; computed or runtime-generated members should be described in vba-types.json or a VBA mock.

Quick Fixes are provided for:

• VBA013 — Add 'Option Explicit': inserts Option Explicit at the top of the file
• VBA016 — Add 'TypeName' to vba-types.json: appends a placeholder entry for the type
• VBA016 — Initialize vba-types.json with all COM type definitions: creates vba-types.json pre-populated with all built-in COM types (shown when the file does not yet exist)

Lint rules (VBA001, VBA009, VBA014, etc.) are off by default. Enable them via settings:

{ "vba-runner.lint.enabled": true }

or selectively:

{ "vba-runner.lint.enabledCodes": ["VBA009", "VBA014"] }

External Type Definitions (vba-types.json)

To add member completion for types not built into the extension — such as custom COM objects, mock classes, or Excel types not yet listed — create vba-types.json in your workspace root:

{
  "MyComObject": [
    { "label": "DoWork",  "kind": "Method",   "detail": "DoWork(arg As String) As Boolean" },
    { "label": "Status",  "kind": "Property", "detail": "Status As Long" }
  ],
  "MyHelper": [
    { "label": "Compute", "kind": "Function", "detail": "Compute(x As Long) As Double", "returnType": "myresult" }
  ]
}

Fields:

Initialization via Quick Fix:

When a VBA016 diagnostic appears for an unknown type, the Quick Fix menu offers:

• Add 'TypeName' to vba-types.json — adds a placeholder entry for that type
• Initialize vba-types.json with all COM type definitions — creates the file pre-populated with all built-in types (Scripting.Dictionary, Range, Worksheet, etc.)

vba-types.json entries take priority over the built-in definitions, so you can override any built-in type's member list.

The file is reloaded automatically whenever it changes.

Code Lens

Inline action buttons appear above each procedure declaration.

Formatting

Press Shift+Alt+F (or right-click → Format Document) to auto-format the file. Also works with "editor.formatOnSave": true in VS Code settings.

Formatting rules include:

• Consistent indentation for Sub / Function / If / For / With / Select Case
• Case labels are aligned with the Select Case keyword
• Keyword casing is normalized to the standard VBA style

Refactoring

Available from the Command Palette (Ctrl+Shift+P) or via Code Lens.

Call Graph

Open the Command Palette (Ctrl+Shift+P) and run:

• VBA: Show Call Graph — Display the call graph starting from the procedure at the cursor
• VBA: Show in Call Graph — Highlight the procedure at the cursor in the full graph

Testing

Test Stub Generation

Click the Untested Code Lens button to generate a Test_<ProcedureName> stub. On first use, you will be asked where to place tests:

• Same file — Appends the stub to the end of the current .bas file
• Separate file — Creates <FileName>Test.bas and appends there

The choice is saved to workspace settings (vba-runner.test.location).

Inline Test Results

After running tests with the ▶ Run Code Lens on a test procedure, the result is shown inline:

• ✓ 3ms — test passed in 3 ms
• ✗ Expected 1 but got 2 — test failed with the first line of the assertion message

The Test Explorer can run all discovered Test_ procedures or only the selected item. A targeted run evaluates only that procedure and loads supporting .bas / .cls files from the same directory.

Extension diagnostics can be tested without launching VS Code. evalVBASingle and evalVBAModules send the exact inline VBA source used by existing engine tests through both the engine and the published LSP diagnostic path at the called-procedure boundary. Diagnostics are scoped to that procedure, so an uncalled sibling does not fail the test. For example, the Private Const test in tests/spec/parse-as-class.test.ts checks its engine result and that no LSP Error is reported from the same String.raw source. tests/lsp/extension-diagnostics-harness.test.ts separately checks the VS Code-facing DiagnosticCollection conversion, including range, severity, message, source, and code.

Mock Skeleton Generation

Run VBA: Generate Mocks from the Command Palette to analyze Excel object dependencies (Worksheet, Range, etc.) in the source file and generate a mock skeleton at __mocks__/ExcelObjects.bas.

VBA Debugger Integration

With a .bas file open, press F5 to launch the file with the VBA Runner debugger (no launch.json required).

In addition to ordinary breakpoints, the debugger accepts a VBA expression in condition and a positive hit count in hitCondition. While paused, you can use Step Over / Step Into / Step Out / Continue, request a manual pause, inspect locals and arguments, evaluate watch expressions, and assign existing local variables. Runtime errors stop at the raising statement with its call stack available to the client.

setVariable only changes existing local variables; array elements, object members, unknown names, and writes while running are not supported.

Debug.Print Output

Debug.Print output is directed to a dedicated VBA Debug Output Channel (separate from the VBA Runner log), which opens automatically when output is produced.

Settings

Documentation

• Documentation hub — Goal-oriented guides (users / developers)
• LSP.md — LSP design and implementation (for developers)
• REFERENCE.md — Detailed specs
• README.md — Project overview

Repository

github.com/jca02266/vba-runner