[Demonstration 1]

[Buggy Method]
public static <T> Supplier<T> memoize(Supplier<T> original) {
    return new Supplier<T>() {

        boolean initialized;

        Supplier<T> delegate = this::firstTime;

        public T get() {
            return delegate.get();
        }

        private synchronized T firstTime() {
            if (!initialized) {
                T value = original.get();
                delegate = () -> value;
                initialized = true;
            }
            return delegate.get();
        }
    };
}

[Buggy Hunk]
public static <T> Supplier<T> memoize(Supplier<T> original) {

[Patch]
private static <T> Supplier<T> memoize(Supplier<T> original) {

[Demonstration 2]

[Buggy Method]
public static <T> T parse(@NonNull String str, @NonNull Class<T> clazz, T fallback) {
    val conv = get(clazz);
    return conv != null ? conv.parse(str) : fallback;
}

[Buggy Hunk]
val conv = get(clazz);

[Patch]
val conv = forClass(clazz);

[Demonstration 3]

[Buggy Method]
private int findInLine(final Line line, final String search, final boolean ignoreCase, final int end) {
    String nextText = line.getText();
    if (ignoreCase) {
        nextText = nextText.toLowerCase();
    }
    if (end == -1) {
        return nextText.lastIndexOf(search);
    }
    return nextText.lastIndexOf(search, end);
}

[Buggy Hunk]
return nextText.lastIndexOf(search, end);

[Patch]
return nextText.lastIndexOf(search, end -1);