`LoggerStringConcat` currently offers to convert calls to `Logger` methods with overloads taking message formats. But Java 8 introduces more convenient overloads taking `Supplier<String>`. I tried the following very crude microbenchmark (yes, I know, YMMV and I ought to be using a proper framework):

import java.util.logging.Level;
import java.util.logging.Logger;
public class Demo {
    private static final Logger LOGGER = Logger.getLogger(Demo.class.getName());
    public static void main(String[] args) {
        String x = "whatever";
        int y = 99;
        for (int i = 0; i < 5; i++) {
            System.err.print("naïve 1: ");
            time(() -> LOGGER.fine("blah blah " + x));
            System.err.print("template 1: ");
            time(() -> LOGGER.log(Level.FINE, "blah blah {0}", x));
            System.err.print("supplier 1: ");
            time(() -> LOGGER.fine(() -> "blah blah " + x));
            System.err.print("naïve 2: ");
            time(() -> LOGGER.fine("blah blah " + x + y));
            System.err.print("template 2: ");
            time(() -> LOGGER.log(Level.FINE, "blah blah {0}", new Object[] {x + y}));
            System.err.print("supplier 2: ");
            time(() -> LOGGER.fine(() -> "blah blah " + x + y));
        }
    }
    static void time(Runnable r) {
        doTime(r, false);
        doTime(r, true);
    }
    static void doTime(Runnable r, boolean measure) {
        long start = System.nanoTime();
        for (int i = 0; i < 100_000_000; i++) {
            r.run();
        }
        long end = System.nanoTime();
        if (measure) {
            System.err.printf("took %.3fs%n", (end - start) / 1_000_000_000.0);
        }
    }
}

which for me using JDK 8u131 on Linux produced

naïve 1: took 1.487s
template 1: took 0.043s
supplier 1: took 0.357s
naïve 2: took 2.325s
template 2: took 2.064s
supplier 2: took 0.390s
naïve 1: took 1.615s
template 1: took 0.440s
supplier 1: took 0.362s
naïve 2: took 2.605s
template 2: took 2.020s
supplier 2: took 0.361s
naïve 1: took 1.783s
template 1: took 0.352s
supplier 1: took 0.359s
naïve 2: took 2.508s
template 2: took 2.132s
supplier 2: took 0.365s
naïve 1: took 1.864s
template 1: took 0.413s
supplier 1: took 0.428s
naïve 2: took 2.580s
template 2: took 2.174s
supplier 2: took 0.367s
naïve 1: took 1.854s
template 1: took 0.365s
supplier 1: took 0.368s
naïve 2: took 2.595s
template 2: took 2.154s
supplier 2: took 0.363s

My rough takeaway is that the `Supplier<String>` version is potentially slower on cold code for the one-argument case but may be faster for two (and I suppose more).

At any rate, it would be nice for the hint to offer to use the Java 8 version when the source level is 8+. Sometimes faster than the current fix, and almost always more readable.

If the order of fixes matters, I suppose I would recommend the 8 version first for 2+ args, though I think I have seen the editor just show all available fixes in a random order—perhaps timing-sensitive.