jade-recipe-1.7-1.8-lambda-conversion
Converts anonymous single-abstract-method (SAM) inner classes to Java 8 lambda expressions. Agent-mode recipe: the shard contract names the files and flagged sites; this document defines the transform
SKILL.md.claude/skills/java-migration-skill-registry/1.7-to-1.8/jade-recipe-1.7-1.8-lambda-conversion/SKILL.md
GitHubjade-recipe-1.7-1.8-lambda-conversion — anonymous SAM class -> lambda
Java SE 8 (JEP 126) lets an anonymous inner class that implements exactly one abstract method be replaced by a lambda expression. This recipe is agent mode because deciding whether a given flagged site is convertible needs real judgment — reading the anonymous class body, the interface/superclass it implements or extends, and how the instance is used — not just regex.
Scope of one task
You receive a shard contract. Edit only the files listed in
editable_files. read_only_context is there for you to read when you need
to resolve an interface's method count, a superclass's fields, or a
JADE-FLAG:LAMBDA_CONVERSION site's surrounding method — never modify it.
entry_points names the flagged sites (file + line) inside your
editable_files to process.
Transform
For each flagged site in entry_points:
- Read the flagged line and locate the
new <Type>(<args>) { ... }anonymous class expression the flag marks. - Identify what
<Type>is — an interface or a concrete/abstract class — and how many abstract methods it declares (for an interface) or how many methods the anonymous body overrides (for a class). - Only if it is a true single-abstract-method case, rewrite the
anonymous class to a lambda:
new Runnable() { public void run() { BODY } }->() -> { BODY }new Thread() { public void run() { BODY } }->new Thread(() -> { BODY })(the constructor argument form —Threaditself is a class, but its single-methodRunnable-shaped override is the well-known convertible idiom used throughout this codebase)new ActionListener() { public void actionPerformed(ActionEvent e) { BODY } }->(ActionEvent e) -> { BODY }(and the analogous form for any other genuine single-method listener interface:ItemListener,ChangeListener,Callable<V>,Comparable<T>, a JADE-declared single-method interface such asInChannel.DispatcherorConnectionFactory, etc.)- Preserve the method body, parameter names, and any generic type
arguments on
<Type>exactly.
- Remove the
// JADE-FLAG:LAMBDA_CONVERSIONcomment for that site on success.
When NOT to transform (report SKIPPED)
Leave the code untouched and report SKIPPED for the site when <Type> or
the anonymous body is any of:
- A field. The anonymous class declares its own instance field(s) — lambdas have no instance state of their own beyond captured locals.
- Multiple methods. The anonymous class overrides more than one method
from its interface/superclass (e.g. a
MouseAdapter/WindowAdapteroverride that implements just one of several available callbacks is still a multi-method type — not convertible even though only one is used here). - A
this-qualified self-reference. The body refers to the anonymous class's own instance via a qualifiedthis(e.g.Outer.thisis fine — that is the enclosing instance and lambdas keep that working identically — but a bare, unqualifiedthismeaning the anonymous class itself does not carry over to a lambda, which has nothisof its own). - A multi-abstract-method interface, or an abstract class with more
than one abstract method (
AbsoluteCounterValueProviderin this codebase is one such case — it is an abstract class, not an interface, so it is never convertible regardless of how many methods are overridden). - An extends-by-name of a concrete class whose constructor does
meaningful work beyond the default (e.g.
new RemoteDFRequester(remoteDF, s) { ... },new OneShotBehaviour(this) { ... }) — the constructor call itself is not representable as a lambda.
For a SKIPPED site, insert // JADE-MODERNIZATION-DEFERRED:LAMBDA_CONVERSION <reason>
in place of the flag comment, naming which of the categories above applied.
If you converted a site but are not fully certain the captured-variable
semantics or method resolution are identical, report NEEDS_REVIEW instead
of FIXED — never guess.
Invariants
- No edit outside
editable_files. - No public signature changes — this rule is
body-local; every edit stays confined to the expression that creates the anonymous class (a local variable initializer, a field initializer, or a method-call argument). The enclosing field/local/parameter's declared type and every method signature in the file are untouched. - No new imports needed — a lambda targeting an existing interface requires nothing beyond what the anonymous class already used.
Status to report
| status | when |
|---|---|
FIXED |
genuine SAM case, rewritten to a lambda |
SKIPPED |
field state, multiple methods, unqualified this, multi-abstract-method type, or meaningful-constructor class extension |
NEEDS_REVIEW |
rewritten, but capture/resolution semantics not certain |
FAILED |
file unreadable, or the flagged expression is not present |