Lombok ExtMethod AutoComplete

English | 中文

A VS Code extension that provides intelligent auto-completion for Lombok @ExtensionMethod static methods in Java files.

When you annotate a class with @ExtensionMethod and call a method on an expression, Lombok treats the first parameter of the utility method as the receiver — this extension makes those methods appear in the completion popup just like native methods.

Features

• Auto-completion — suggests @ExtensionMethod static methods when typing . or .prefix on an expression
• Type filtering — only compatible methods (matching the receiver's type) are suggested, with fallback to local variable declaration parsing when Hover Provider fails
• Prefix filtering — further narrows candidates as you type characters after the dot
• Snippet insertion — parameters are inserted with named placeholders (e.g., ${1:int_maxWidth}), automatically omitting the receiver parameter
• Generic type support — methods with type parameters like <T> are properly parsed; generic parameters are treated as compatible with any type
• Workspace and JAR sources — methods from both local source files and JAR dependencies are resolved
• Multi-stage source resolution — definition provider → findFiles → path derivation → same-directory search, with graceful fallback
• Chained calls — expr.method1(arg).method2(). chains are fully supported; each step's type is resolved via JDT LS hover, with fallback to return-type inference from the cached method list
• Live cache invalidation — when a workspace source file is saved, its cached methods are automatically cleared; TTL 10 minutes

Installation

Search for Lombok ExtMethod AutoComplete in the VS Code extension marketplace, or run:

ext install JensenQi.lombok-extmethod-autocomplete

Usage

1. Add Lombok to your project (Maven/Gradle)
2. Annotate a class with @ExtensionMethod:

import lombok.experimental.ExtensionMethod;
import org.apache.commons.lang3.StringUtils;

@ExtensionMethod(StringUtils.class)
public class MyService {

    public void process(String input) {
        // Type "." or ".prefix" after the expression to see extension methods
        input.  ← shows abbreviate, capitalize, etc.
        input.abbr ← shows abbreviate(int maxWidth), etc.
        // Tab to insert snippet: methodName(argType_argName)
        x.abbreviate(int_maxWidth)
    }
}

Multiple extension classes are supported:

@ExtensionMethod({StringUtils.class, ObjectUtils.class, MyUtils.class})

How It Works

1. Annotation Parsing (annotationResolver.ts) — scans the current document for @ExtensionMethod annotations using regex, resolves simple class names to FQN via imports and package declaration. Wildcard imports (import foo.*) cannot be resolved — use explicit imports for extension classes.

2. Source Resolution (jdtlsHelper.ts) — for each FQN, searches source in priority order:

   • Calls vscode.executeDefinitionProvider to trigger JDT LS go-to-definition. The returned URI is either:
     • JAR class: jdt://contents/... virtual file URI — opens decompiled source (FernFlower) via openTextDocument
     • Workspace class: file://path/to/... — reads the source file directly
   • Falls back to workspace.findFiles if the definition provider fails
   • Falls back to path derivation from the reference document's package path
   • Finally tries the same directory as the reference document

3. Method Parsing (jdtlsHelper.ts) — extracts public static method signatures (name, parameter types, return type) from source using regex; parameter names are stripped; constructors and lambda methods are skipped.

4. Type Filtering (completionProvider.ts) — determines the receiver expression's type:

   • Prefers vscode.executeHoverProvider to get the expression type
   • Falls back to parseLocalVarType (regex-based local variable declaration parser) when Hover Provider fails
   • Only methods whose first parameter is compatible with the expression type are kept; generic type parameters (single letters like T) are treated as compatible with any type
   • Also filters by characters typed after the dot (prefix filtering)

5. Completion — each method becomes a CompletionItem (isIncomplete: true to retrigger on each keystroke), label shows methodName(args...), the first parameter (receiver) is dropped from the snippet since Lombok passes the target expression as the first argument automatically.

Module Structure

Commands

These commands are only visible in the command palette when lombokExtensionMethod.debugEnabled is true.

Configuration

Requirements

• VS Code 1.85+
• Extension Pack for Java (for JDT LS support)
• A project using Lombok with @ExtensionMethod

Limitations

• Receiver type filtering relies on VS Code's Hover Provider. If neither hover nor local variable parsing can determine the type, all extension methods are shown (no filtering).
• Wildcard imports (import some.package.*) are not supported for class resolution — use explicit imports for extension classes.
• Complex generic bounds (<T extends Comparable<T>>) may not parse correctly in method signatures.

Development

npm install
npm run compile
npx vitest run         # run unit tests
npx vsce package       # package .vsix

Launch the extension in VS Code by pressing F5 with the project open in a separate window.

License

Apache2.0