Ignis Arc Java IDE Extension Pack

A premium, high-performance VS Code extension pack designed to bring the deep project navigation, dependency browsing, OOP reference metrics, decompilation, and bytecode performance tuning power of heavyweight IDEs (IntelliJ IDEA / Eclipse) directly into VS Code, with zero extra JVM process memory overhead and real-time codebase metrics analysis.

[!IMPORTANT]
Extension Dependency & Co-processing:
This extension strictly depends on Language Support for Java(TM) by Red Hat (redhat.java).
Rather than spawning a separate heavy Java process, it compiles into an OSGi bundle that loads directly inside the shared JDT LS JVM process to ensure zero extra CPU and memory footprint.

🎨 Features

1. Ignis Arc Java Explorer (Native-Theme & Filesystem Integration)

The Explorer renders a clean, native directory tree combined with dynamic Java Libraries:

• Native Directory Trees: Mimics VS Code's native file explorer with files and folders ordered alphabetically (folders first).
• Active Theme Integration: Uses file resourceUri mapping with a custom jdt-class scheme to automatically inherit your active VS Code File Icon Theme (e.g. Material Icon Theme or vscode-icons) without triggering any filesystem query overhead!
• JDK & External Dependency Containers:
  • JDK System Library: Displays the JRE container labeled dynamically with your active JDK environment (e.g., JDK System Library [java-21-openjdk-amd64]).
  • Referenced Libraries: Lists all Maven, Gradle, and user-referenced external .jar dependencies.
• Lazy-Loaded Dependency Browser: Expands JARs to lazy-load packages, and packages to lazy-load class files directly from the JDT LS index—yielding zero lag even in massive projects.
• Instant Class Decompiler: Simply double-click any compiled .class file in your referenced libraries to decompile and display its source code with full syntax highlighting natively via Red Hat JDT LS jdt:// protocol.
• Smart Activity Bar Visibility: The Ignis Arc Sidebar Icon automatically shows up when a Java project is detected and completely hides in non-Java workspaces, keeping your sidebar clean.

2. Specialized OOP Usages & Implementations Code Lenses

A highly optimized, thread-safe Code Lens provider that displays the active usages, implementations, or inheritance metrics directly above your Java elements:

• OOP Specialized Roles:
  • For Interfaces: Automatically queries and displays 🔗 X implementations (e.g., 🔗 3 implementations). Clicking on it slides open VS Code's native Peek View, listing all implementer classes!
  • For Classes: Queries and displays 🔗 X subclasses (e.g., 🔗 2 subclasses) if the class is inherited, and seamlessly falls back to 🔗 X usages if it is a concrete class.
  • For Enums, Methods, Fields, Constants, and Enum Members: Tracks general references, displaying 🔗 X usages.
• Definitions Filtering: References counts automatically filter out the symbol's own declaration location, allowing never-referenced variables to accurately display 🔗 no usages (or 🔗 no implementations).
• Double-Stage Lazy Resolution (Performance-First ⚡):
  • provideCodeLenses: Fast-scans the active document's symbols hierarchically without querying the LSP, guaranteeing zero editing delay.
  • resolveCodeLens: Queries references only when the Code Lens actually scrolls into your viewport. Scales perfectly in enterprise-scale codebases!

3. Ignis Arc McCabe Complexity Lenses & Refactoring Sidebar

A premium code-review sidebar panel and dynamic method lenses that scan your active Java workspace for complex methods, sorting them by cyclomatic complexity to help you instantly spot refactoring hot paths:

• McCabe Cyclomatic Complexity Standard: Scans your source files for decision paths + 1, including looping constructs (for, while, do-while, enhanced for), conditionals (if), catch clauses (catch), switch branches (case), short-circuit logical operators (&&, ||), and ternary conditional operators (? :).
• Method Name Line Snapping & Lombok Filtering:
  • Complexity is computed and displayed precisely on the method name's line rather than overlapping on annotations.
  • Compiler-synthesized and Lombok-generated methods (e.g., @EqualsAndHashCode) are automatically filtered out, ensuring your dashboard focuses purely on developer-written code.
• Dynamic Go-to Jump: Click on any method in the sideview tree list to instantly open the corresponding .java file, highlight the method signature line, and center the editor viewport on it.
• Save-Driven Debounced Scan: Automatically refreshes the sidebar list upon saving a .java file with a 500ms debounce to prevent disk IO and CPU overload.

4. Ultimate Bytecode Performance Tuning Suite (Scroll Sync, Hover Explainer, & LVT)

Bring advanced low-level bytecode tuning directly into VS Code, with class structures, constant pools, variable tables, and instruction-level tracking synced side-by-side:

• 🔁 Synchronized Scrolling & Highlighting: Open your source code and bytecode side-by-side. Scrolling or selecting a line in the source code automatically scrolls to and highlights the matching JVM bytecode instructions via built-in // IgnisSrcLine markers!
• 📖 JVM Instruction Hover Explainer: Hover over any compiled JVM mnemonic (like invokevirtual, aload_0, getfield, dup, new) to view a premium popup showing its operand stack transition diagram and detailed runtime execution mechanics.
• 📋 Local Variable Table (LVT) Explorer: Prepend a clean ASCII table mapping local variable slots to their actual handwritten variable names and type descriptors at the beginning of each method bytecode body. No more guessing slot indices!
• ⚡ Constant Pool Explorer: Displays a beautifully formatted table at the very top of full class decompilations, mapping all class-level strings, constants, and method/field descriptors in detail.
• 🧹 Lombok & Synthetic Method Filtering: Toggle compiler-synthesized or Lombok methods out of both the method picker and decompilation views via a single configuration switch to clean up low-level noise.

⚙️ Extension Settings

You can customize thresholds, toggles, and features in your global VS Code settings.json:

⚡ Under the Hood (Architecture & Design)

Traditional Java extensions launch multiple background JVM processes to compute code metrics or display projects, incurring massive CPU and memory penalties.

Ignis Arc Java IDE Extension Pack achieves maximum efficiency by:

1. 100% JVM Sharing: Compiles into an Eclipse Equinox OSGi Plugin Bundle that loads directly inside vscode-java's active Language Server process (Eclipse JDT LS).
2. Zero Overhead: Shares JDT's built-in AST parser, classpath resolution engine, and index database. Zero extra Java processes are spawned, ensuring lightweight memory footprints.
3. Client-Server OSGi Command Delegates: Translates lightweight frontend TypeScript requests to Equinox-delegated commands (java.execute.workspaceCommand) executed directly on the running JVM.

🔧 Developer & Build Guide

The project includes a completely self-contained compiler and packaging pipeline that bypasses local JDK environment corruption:

Prerequisites

• Bun or Node.js (for TypeScript compilation and VSIX packaging)
• Standard Java JRE (already provided by system)

Build & Package Commands

1. Recompile & Package Extension: Run the entry shell script to compile the Equinox backend via Eclipse Batch Compiler (ECJ), transpile TypeScript, and output the optimized .vsix package:

   chmod +x pack.sh
   ./pack.sh
   

2. Install/Update in VS Code:

   code --install-extension ignis-arc-java-ide-extension-0.1.7.vsix
   

3. Clean Cache: Always run Java: Clean Java Language Server Workspace from the VS Code command palette (Ctrl+Shift+P) after updating the backend JAR to force Equinox to load the fresh plugin commands.