[Demonstration 1]

[Buggy Method]
protected Map newMap(Map prototype, Type type) throws InstantiationException, IllegalAccessException {
    Map result;
    if (type instanceof Class && Map.class.isAssignableFrom((Class<?>) type)) {
        result = (Map) ((Class<?>) type).newInstance();
    } else {
        result = new LinkedHashMap(prototype.size());
    }
    return result;
}

[Buggy Hunk]
if (type instanceof Class && Map.class.isAssignableFrom((Class<?>) type)) {

[Patch]
if (type instanceof Class && Map.class.isAssignableFrom((Class<?>) type) && !type.equals(Map.class)) {

[Demonstration 2]

[Buggy Method]
private void writeSources() {
    List<Map.Entry<TypeElement, List<ExecutableElement>>> entries = new ArrayList<Map.Entry<TypeElement, List<ExecutableElement>>>(methodsByClass.entrySet());
    for (int i = 0; i < entries.size(); i++) {
        Map.Entry<TypeElement, List<ExecutableElement>> entry = entries.get(i);
        TypeElement subscriberClass = entry.getKey();
        if (classesToSkip.contains(subscriberClass)) {
            continue;
        }
        BufferedWriter writer = null;
        try {
            PackageElement packageElement = getPackageElement(subscriberClass);
            String myPackage = packageElement.getQualifiedName().toString();
            String subscriberClassName = getClassString(subscriberClass, myPackage);
            String infoClassName = getInfoClass(subscriberClass, myPackage);
            JavaFileObject sourceFile = processingEnv.getFiler().createSourceFile(myPackage + '.' + infoClassName);
            writer = new BufferedWriter(sourceFile.openWriter());
            writer.write("package " + myPackage + ";\n\n");
            writer.write("import de.greenrobot.event.SubscriberInfo;\n");
            writer.write("import de.greenrobot.event.SubscriberMethod;\n");
            writer.write("import de.greenrobot.event.ThreadMode;\n\n");
            writer.write("/** This class is generated by EventBus, do not edit. */\n");
            writer.write("public class " + infoClassName + " extends SubscriberInfo {\n");
            writer.write("    public " + infoClassName + "() {\n");
            TypeElement nextEntry = nextEntry(entries, entry, i);
            String next = getNextValue(myPackage, nextEntry);
            String infoSuperClass = getSuperclassInfoClass(subscriberClass, myPackage);
            writeLine(writer, 2, "super(" + subscriberClassName + ".class,", infoSuperClass + ",", next + ");");
            writer.write("    }\n\n");
            writer.write("    protected SubscriberMethod[] createSubscriberMethods() {\n");
            writer.write("        return new SubscriberMethod[] {\n");
            Set<String> methodSignatures = new HashSet<String>();
            writeMethods(writer, entry.getValue(), methodSignatures);
            writer.write("        };\n");
            writer.write("    }\n}\n");
        } catch (IOException e) {
            throw new RuntimeException("Could not write source for " + subscriberClass.getQualifiedName(), e);
        } finally {
            if (writer != null) {
                try {
                    writer.close();
                } catch (IOException e) {
                    //Silent
                }
            }
        }
    }
}

[Buggy Hunk]
writeMethods(writer, entry.getValue(), methodSignatures);

[Patch]
writeMethods(writer, entry.getValue(), methodSignatures, myPackage);

[Demonstration 3]

[Buggy Method]
public Object unflattenValue(String paramName, Type type, Object value, ObjectRefsManager manager) {
    if (type instanceof Class) {
        Class<?> clazz = (Class<?>) type;
        if (isPrimitiveClass(clazz)) {
            return value;
        } else if (clazz.isEnum()) {
            return unflattenEnumConstant(type, value, clazz);
        } else {
            if (value instanceof String) {
                return unflattenRemoteObject(type, (String) value, manager);
            } else if (value instanceof Props) {
                Props props = (Props) value;
                Class<?> newClazz = getOrCreateClass(props);
                if (newClazz != null) {
                    clazz = newClazz;
                }
                return unflattedComplexType(clazz, props, manager);
            } else {
                throw new ProtocolException("A objectRef coded with a String or a Props is expected for param type '" + type + "'");
            }
        }
    } else if (type instanceof ParameterizedType) {
        ParameterizedType pType = (ParameterizedType) type;
        if (((Class<?>) pType.getRawType()).isAssignableFrom(List.class)) {
            return unflattenList(paramName, (List<?>) value, pType.getActualTypeArguments()[0], manager);
        }
        if (((Class<?>) pType.getRawType()).isAssignableFrom(Map.class)) {
            return unflattenMap(paramName, (Props) value, pType.getActualTypeArguments()[0], manager);
        }
    }
    throw new ProtocolException("Type '" + type + "' is not supported");
}

[Buggy Hunk]
pType.getActualTypeArguments()[0], manager);

[Patch]
pType.getActualTypeArguments()[1], manager);