What

Teaches the rewrite { } to { } recipe DSL to treat varargs methods as variadic by default. When the before pattern targets a method whose declared last parameter is varargs, the args the author places in that slot become a representative group rather than a literal count — so the recipe matches call sites of any arity and carries them all through. The author writes the natural shape; no *args ceremony required.

// matches Arrays.asList(...) of any arity (2, 4, even 0 -> List.of())
rewrite { a: Any, b: Any, c: Any -> java.util.Arrays.asList(a, b, c) } to { a, b, c -> java.util.List.of(a, b, c) }

// natural String.format -> String.formatted (JDK 15+)
rewrite { fmt: String, a: Any, b: Any -> java.lang.String.format(fmt, a, b) } to { fmt, a, b -> fmt.formatted(a, b) }

The variadic group can be repositioned in the after template — the motivating slf4j case moves a trailing Throwable from before the varargs run to after them (log(msg, t, params…) → error(msg, params…, t)). An explicit .strictArity() modifier opts out into exact-arity matching, and the explicit spread form { args: Array<Any> -> asList(*args) } is also supported.

How

• Matcher: a varargs callee is always matched with prefix…, .. — a MethodMatcher matches the declared signature, where varargs is a single array param, so a fixed (*,*,*) spec can never match it. Fixed prefix params are typed (Kotlin builtins → Java FQN) to avoid sibling-overload matches like String.format(Locale, String, Object...).
• After template: carries a control-char sentinel + a V<k> substitution source. At apply time the runtime expands the sentinel to one #{any()} per matched arg and splices getArguments()[k..end] (the canonical zero-arg [J.Empty] collapses to count 0). Placeholders bind positionally, so in-place expansion keeps template and substitution array aligned. This handles pass-through, reorder, and .strictArity() (a runtime exact-count guard) uniformly.
• Surface: to now returns a RewriteRule so (rewrite { } to { }).strictArity() chains off it; the FIR checker accepts strictArity as a valid rewrite terminal.

Bonus: the mapped-type fallback customizer now preserves varargs

• Re-exposed Java varargs methods like String.formatted(Object...) (surfaced by rewrite-kotlin: re-expose Java instance methods Kotlin's mapped-type customizer hides #7893) now appear as a real Kotlin vararg args: Any? instead of a plain Array<Any?>. rewrite-kotlin: re-expose Java instance methods Kotlin's mapped-type customizer hides #7893 deliberately punted on this because surfacing isVararg = true tripped IllegalStateException: Vararg expression has incorrect type in fir2ir — the cause was declaring the param as an invariant Array<Any?>; a Kotlin vararg's type is the out-projected Array<out Any?>. With that fix authors call x.formatted("x", "y") naturally, and formatted becomes a first-class variadic callee that the DSL handles for free.

Testing

New cases in RecipePluginRewriteTest (compile-and-run via the K2 plugin + rewriteRun): by-example pass-through (Java + Kotlin sources), explicit spread, String.format → formatted, the slf4j reorder, and .strictArity(). RecipeMappedTypeFallbackTest updated to assert the natural formatted("x", "y") call. Full :rewrite-kotlin:test is green.