VS Code B4X IDE Companion

Comprehensive IDE companion for the B4X family (B4A, B4i, B4J, B4R) — IntelliSense · LSP · Type Inference · Diagnostics · Code Actions · Formatting · Theme Import · Project Management

Overview

VS Code B4X IDE Companion brings the B4X development experience into Visual Studio Code. It provides a full developer toolkit including a local Language Server Protocol (LSP) backend, fast workspace indexer, cross-file type inference, structural code formatting, persistent SQLite-backed library caching, and server-side refactoring — all designed to work offline-first with your existing B4X installation.

The extension auto-discovers platform INI configuration files for all four B4X platforms from %APPDATA%\Anywhere Software\, so library paths, additional libraries folders, fonts, and themes are picked up automatically without manual settings.

Features

Language Intelligence

Code Formatting

Syntax & Editing

Diagnostics & Code Actions

Document Links

LSP Backend

Library Support

Project Management

Platform INI & Theme Integration

Developer Tools

B4X Companion Context Menu

Right-click in any .bas or .b4x editor to access the B4X Companion submenu. All items are grouped by function and only appear when editing B4X files.

Navigation

Formatting

Comments & Cleanup

Tools

External

These items are hidden from the Command Palette (Ctrl+Shift+P) — they only appear in the right-click context menu.

Quick Start

1. Install the extension from the VS Code Marketplace (or load the .vsix manually).
2. Open VS Code and run Ctrl+Shift+P → B4X Companion: Open B4X Project…
3. Select your .b4a, .b4i, .b4j, or .b4r project file.
4. The extension will:
   • Add the project folder to your workspace
   • Discover platform INI files and library paths automatically
   • Load allowed XML libraries and .b4xlib archives
   • Extract and index .bas modules from .b4xlib files
   • Start the LSP language server
   • Apply font and theme hints from your B4X IDE configuration

Tip: You don't need to configure any paths manually. The extension reads b4xV5.ini from %APPDATA%\Anywhere Software\ for each platform and discovers library folders automatically. Override paths in Settings only if your installation is non-standard.

Commands

Note: Some commands are hidden from the Command Palette and are only accessible via the editor context menu (right-click → B4X Companion). These include navigation commands (Go to Definition, Find References, etc.), formatting commands, and utility commands. Technical maintenance commands (Refresh Library Index, Clear Library Cache, Set Platform Install Path) are also hidden to reduce clutter.

Extension Settings

All settings are prefixed with b4xIntellisense. in VS Code.

How It Works

Platform Discovery

On activation (or when a project is opened), the extension scans %APPDATA%\Anywhere Software\ for each platform's INI file:

From each INI file, the extension reads:

• LibrariesFolder — path to installed platform libraries (XML descriptors)
• AdditionalLibrariesFolder — path to user-added libraries (XML and .b4xlib)
• PlatformFolder — used to derive the Android SDK path for adb
• FontName2 / FontSize2 — editor font hints
• CodeTheme / IdeTheme2 — color theme hints

Library Loading

1. The opened project file (.b4a, .b4i, .b4j, .b4r) is parsed for its LibraryN= entries.
2. Only libraries declared in the project are loaded (project-scoped filtering).
3. For each library name, the extension searches installation and additional library folders for:
   • .xml descriptors → parsed for classes, methods, properties, and fields
   • .b4xlib archives → extracted via node-stream-zip; contained .bas/.b4x modules are indexed
4. Extracted module metadata is cached in a persistent SQLite database.

IntelliSense Stores

The extension maintains four in-memory class stores:

• XML Libraries (XmlLibraryStore) — classes parsed from XML library descriptors
• Workspace Classes (WorkspaceClassStore) — classes from .bas/.b4x files in the workspace (updated on save/edit)
• Common Class (CommonClassStore) — the Common class from Core.xml (Log, Msgbox, StartActivity, etc.) callable without prefix
• Primitive Types (PrimitiveTypeStore) — synthetic class definitions for Int, Float, Double, Long, Byte, Short, Boolean, Char, Object, String, StringBuilder

All four stores are queried for completions, hover, go-to-definition, and signature help.

Type Inference

When you type obj., the extension resolves the type of obj through:

1. Dim declarations in the current file
2. Sub parameter types
3. Local symbol types
4. Primitive type mappings
5. Cross-file inference scanning workspace .bas files

The resolved class is then looked up in both WorkspaceClassStore and XmlLibraryStore to provide member completions.

Go to Definition Resolution Chain

When you press F12 on a symbol, the provider resolves in order:

1. Local Sub/Type in the current document
2. Workspace Sub — searches all .bas modules in the project for a matching Sub name
3. XML Library Method — searches XML library classes for a matching method
4. Workspace Class — user-defined class/module by name
5. XML Library Class — SDK class by name

This means DesignerCreateView in another .bas file will resolve correctly, not just class-level symbols.

Find All References

Searches the entire current file (no scope filtering) plus all .bas/.b4x files on disk under your workspace root — not just open tabs. Results appear in VS Code's native References panel, grouped by file.

Syntax Highlighting & Snippets

• TextMate Grammar — Full B4X syntax highlighting for keywords, types, strings, comments, regions, preprocessor directives, and more.
• Snippets — 100+ common B4X patterns: Sub, If/Then, For/Next, Select Case, Try/Catch, Type, B4XPage, CustomView, SQL, XUI, and platform-specific snippets.
• Semantic Tokens — Variables from Class_Globals / Process_Globals receive additional semantic coloring when used inside methods.

Requirements

• VS Code ≥ 1.95
• Node.js (bundled with VS Code)
• A B4X project with .bas / .b4x source files
• For full library IntelliSense: an installed B4X platform (B4A, B4i, B4J, or B4R) with XML library descriptors

Project Structure

src/
  extension.ts                        – Main extension entry: activation, commands, providers
  b4xAutoclose.ts                     – Auto-close keywords and 3-line Try block on Enter
  b4xCodeLensProvider.ts              – Reference counts above Subs
  b4xDocParser.ts                     – Completion/cursor-context utilities
  b4xDocumentFormattingProvider.ts    – Structural code formatter (5-phase pipeline)
  b4xDocumentHighlightProvider.ts     – Symbol highlighting (read vs. write access)
  b4xDocumentLinkProvider.ts          – Clickable links (#AdditionalJar, LoadLayout, ShowPage)
  b4xDocumentRangeFormattingProvider.ts – Range formatting delegation
  b4xDocumentSymbolProvider.ts        – Outline view / Ctrl+Shift+O
  b4xFoldingRangeProvider.ts          – Code folding
  b4xImplementationProvider.ts        – Go to Implementation (find Sub definitions)
  b4xInlineCompletionProvider.ts      – Ghost text completions with Tab accept
  b4xLocalSymbols.ts                  – Local symbol extraction (Dim, Sub, Types)
  b4xOnTypeFormattingProvider.ts      – Auto-casing on type (space, Enter, colon)
  b4xReferenceProvider.ts             – Find All References (on-disk search)
  b4xRenameProvider.ts                – F2 rename with case preservation
  b4xSelectionRangeProvider.ts        – Smart Expand Selection (Word → Line → Block → Doc)
  b4xTypeDefinitionProvider.ts        – Go to Type Definition (jump to class definition)
  b4xTypeInference.ts                 – Cross-file variable type inference engine
  b4xWorkspaceSymbolProvider.ts       – Ctrl+T workspace symbol search
  callSubDiagnostics.ts               – CallSub target validation
  commonClassStore.ts                 – Common class extraction (Log, Msgbox, etc.)
  extractMethodCodeAction.ts          – Extract Method refactoring code action
  logging.ts                          – File-based logging with timestamps
  lspClient.ts                        – LSP client (connects to server/)
  platformBuilders.ts                 – Platform builder configuration (B4A/B4J)
  platformConfig.ts                   – Multi-platform INI auto-discovery + Registry lookup
  platformIni.ts                      – INI file parser (LibrariesFolder, AdditionalLibraries, etc.)
  primitiveTypeStore.ts               – Primitive type mappings (Int, String, Boolean, etc.)
  projectFile.ts                      – .b4a/.b4i/.b4j/.b4r project parser
  projectStatisticsCore.ts             – Core logic for project statistics collection
  providers/projectStatisticsProvider.ts – Webview dashboard with Chart.js charts
  typeCodeAction.ts                   – Quick-fix for misplaced Type blocks
  typeDiagnostics.ts                  – Type placement diagnostics registration
  typeDiagnosticsCore.ts              – Core diagnostic logic (findMisplacedTypeRanges)
  types.ts                            – Shared B4X type definitions
  unusedSubDiagnostics.ts             – Unused Sub diagnostic provider
  unusedSubDiagnosticsCore.ts         – Core unused Sub detection logic
  unusedLibraryDiagnostics.ts         – Unused Library diagnostic provider
  unusedLibraryDiagnosticsCore.ts     – Core unused library detection logic
  vssettingsImporter.ts               – .vssettings theme file import
  workspaceClassIndex.ts              – Workspace .bas/.b4x file indexer
  xmlLibraryIndex.ts                  – XML library descriptor parser
  storage/
    libraryIndexSqlite.ts             – Persistent SQLite library cache (3-tier fallback)

server/
  server.js                           – LSP server (stdio transport)
  logger.js                           – Server-side logging
  indexer/
    documentManager.js                – Document/text management with symbol tables
    fileSymbolParser.js               – .bas/.b4x file symbol extraction
    globalSymbolTable.js              – Cross-file symbol table
    extractMethod.js                  – Server-side Extract Method logic
    inferParams.js                    – Parameter inference for extracted methods
    workerPool.js                     – Background worker thread pool
    workerTask.js                     – Worker task definitions

snippets/
  b4x.json                            – 100+ B4X code snippets

syntaxes/
  b4x.tmLanguage.json                 – TextMate grammar for B4X

scripts/
  tests/                              – Test scripts for type diagnostics, library index, etc.

test/
  sample workspace with .bas files    – Sample workspace for testing

Known Issues

• The XML parser does not currently handle <event>, <objectwrapper>, or <owner> elements from library descriptors.
• Theme import from .vssettings files performs a best-effort color mapping; some B4A themes may not translate perfectly.

Release Notes

See CHANGELOG.md for full release history.

0.1.418

• Project Statistics Dashboard — Interactive webview with stat cards (Total Lines, Code Lines, Comment Lines, Blank Lines, Modules, Subs, Events, Types), per-module table with totals row, and three Chart.js charts: Line Composition doughnut, Subroutines per Module Top 10, Module Size Breakdown Top 10
• Unused Sub Diagnostics — Detects unused Private and Public Subs, excluding lifecycle Subs and event handlers
• Unused Library Diagnostics — Flags declared libraries whose types are never referenced in project code
• Chart.js Integration — Bundled Chart.js v4.5.1 UMD for offline-capable, theme-aware webview charting
• Improved LSP Resilience — Server allows limited restarts instead of permanent DoNotRestart state
• Fixed Extract Method Dim Parsing — All comma-separated variables in Dim a, b, c As Int are now captured
• Fixed Chart Label Visibility — Bar chart Y-axis labels no longer skip entries
• Fixed Cross-platform Module Names — Platform extensions (.b4a, .b4j) preserved in chart labels

0.1.289

• New B4X Project from Template — Scans platform library folders for .b4xtemplate files and creates new projects from templates
• Template Discovery — Searches both LibrariesFolder and AdditionalLibrariesFolder with [PLATFORM] prefixes
• Template Listing — Sorted by platform, subfolder support, file extension hidden

0.1.272

• Fixed trailing space bug — Case/Return keywords followed by string literals now preserve spacing (Case "btn" instead of Case"btn")
• Fixed ALL-CAPS keyword normalization — ALL-CAPS keywords now correctly normalize to TitleCase (END SUB → End Sub)
• Added B4X primitive type keywords — Int, String, Long, Float, Double, Boolean, Byte, Short, Char, Object get proper casing
• Fixed #Else / #Else If indentation — Preprocessor directive branches now indent correctly
• Fixed # directive corruption — #AdditionalJar:, #Event:, and all # lines are now preserved verbatim (no keyword casing or spacing changes), preventing Windows path breakage

0.1.271

• Removed JAR-to-XML Generator - Cleaned out Java bytecode parsing feature from extension scope
• Command Palette Cleanup - Hidden technical maintenance commands: Refresh Library Index, Clear Library Cache, Set Platform Install Path
• Removed "B4X: " prefix from all command titles for cleaner display

0.1.270

• Go to Implementation — Jump to concrete Sub implementations across workspace modules
• Go to Type Definition — Jump from type name to its class definition (e.g., Button → Button XML class)
• Document Link Provider — Clickable links for #AdditionalJar: paths, LoadLayout("Name") → .bal files, B4XPages.ShowPage("Name") → page modules
• Inline Completion Provider — Ghost text completions with Tab accept for Sub calls
• Document Highlight Provider — Highlights all occurrences of symbol under cursor with read/write distinction
• Selection Range Provider — Smart expand selection: Word → Line → Sub Block → Document
• On-Type Formatting — Auto-casing of keywords as you type (space, Enter, colon triggers)
• Insert Event Handler — Generate event handler Sub templates via command
• Range Formatting — Format only selected text range, not entire document
• Common Class Store — Dedicated extraction of Common class globals (Log, Msgbox, etc.)
• Primitive Type Store — Dedicated store for primitive type mappings and synthetic class definitions
• Block Comment / Un-Block Comment — Comment/uncomment selected lines with B4X ' style
• Format Selection / Un-Format Selection — Apply/remove formatting to selected range only
• Command Palette Cleanup — Hidden technical commands: Refresh Library Index, Clear Library Cache, Set Platform Install Path
• 3-Tier SQLite Fallback — better-sqlite3 (native) → sql.js (WASM) → in-memory fallback
• File-based Logging — Timestamped log files (b4x-log-YYYYMMDD.txt) with workspace root or global storage

0.1.258

• Structural Code Formatter — VB.NET-quality indentation tracking for all B4X block constructs (Sub/End Sub, If/End If, For/Next, Select/End Select, Try/Catch/End Try, Do/Loop, #Region/#End Region, #If/#End If), keyword casing normalization, blank line management
• Document Symbol Provider — Outline view and Ctrl+Shift+O for Subs, Types, Regions, and globals
• Workspace Symbol Provider — Ctrl+T fuzzy search across all workspace modules and XML libraries
• Rename Provider — F2 rename with case preservation across all project files
• Code Lens — Reference counts above Sub declarations
• CallSub Validation — Diagnostics for CallSub/CallSubDelayed targeting non-existent Subs
• Preprocessor Directive Completions — Type # for completions (#If B4A, #Region, AdditionalJar:, etc.)
• Go to Definition Across Modules — Resolves Subs in other .bas files, not just classes
• Find All References On-Disk — Searches all workspace files on disk, not just open tabs
• Hover Action Links — Go to Definition, Find All References, and Search Online in hover tooltips
• Un-Format Document — Strip all leading indentation
• Remove Blank Lines — Compact file to single block
• B4X Companion Context Menu — Right-click submenu with commands organized by category (Navigation, Formatting, Comments, Cleanup, Tools, External)
• Search Online — B4X forum search from context menu for word under cursor
• Peek Definition — Alt+F12 inline definition peek

0.1.248

• Multi-platform auto-discovery for B4A, B4i, B4J, and B4R INI files
• LSP backend with worker pool indexer
• .b4xlib archive extraction via node-stream-zip
• Extract Method code action with preview
• Type diagnostics and quick-fix code actions
• Persistent SQLite library index
• Theme import from B4A install
• Build & Install to device
• GIF/Screenshot capture tools
• Semantic token highlighting for globals
• Session persistence and auto-reload

0.1.0

Initial release with core IntelliSense features.

Contributing

See CONTRIBUTING.md for development setup and guidelines.

License

See LICENSE for details.