[Demonstration 1]

[Buggy Method]
@Override
public <C extends T> DefaultMessagingChannel<C> withFailover(FailoverPolicyBuilder policy) {
    return withFailover(policy.build());
}

[Buggy Hunk]
public <C extends T> DefaultMessagingChannel<C> withFailover(FailoverPolicyBuilder policy) {

[Patch]
public DefaultMessagingChannel<T> withFailover(FailoverPolicyBuilder policy) {

[Demonstration 2]

[Buggy Method]
@SuppressWarnings("unchecked")
public Class<? extends JSONRemote> generateProto(Class<? extends JSONRemote> clazz) throws NotFoundException, CannotCompileException {
    CtClass result;
    CtClass clazzCt = getCt(clazz);
    String outClassName = clazz.getName() + "__RPC";
    if (clazz.isInterface()) {
        System.out.println("Implementing " + clazz.getName() + " @ " + outClassName);
        result = pool.makeClass(outClassName, GENERATED_IMPL_CLASS);
        result.addInterface(JSON_REMOTE_INTERFACE);
        result.addInterface(pool.get(clazz.getName()));
        //Create constructor to invoke
        CtConstructor constructor = CtNewConstructor.make(new CtClass[] { JSON_RPC_CLIENT_CLASS, STRING_CLASS }, new CtClass[] {}, result);
        constructor.setModifiers(Modifier.PUBLIC);
        result.addConstructor(constructor);
    } else {
        System.out.println("Extending " + clazz.getName() + " @ " + outClassName);
        //is abstract class JSONRpcGeneratedImplementation(JSONRpcClient, String)
        result = pool.makeClass(outClassName, pool.get(clazz.getName()));
        result.addInterface(RPC_IMPL_CLASS);
        CtField rpcClientField = new CtField(JSON_RPC_CLIENT_CLASS, "__rpcClient", result);
        rpcClientField.setModifiers(Modifier.PRIVATE | Modifier.FINAL | Modifier.TRANSIENT);
        result.addField(rpcClientField);
        CtField rpcUrlField = new CtField(STRING_CLASS, "__rpcUrl", result);
        rpcUrlField.setModifiers(Modifier.PRIVATE | Modifier.FINAL);
        result.addField(rpcUrlField);
        //Create constructor to invoke
        result.addConstructor(CtNewConstructor.make(new CtClass[] { JSON_RPC_CLIENT_CLASS, STRING_CLASS }, new CtClass[] {}, "{super();$0.__rpcClient = $1;$0.__rpcUrl=$2;}", result));
        //implement JSONRpcImplementation (generate getters)
        CtMethod getClientMethod = CtNewMethod.getter("getClient", rpcClientField);
        getClientMethod.setModifiers(Modifier.PUBLIC | Modifier.FINAL);
        result.addMethod(getClientMethod);
        CtMethod getUrlMethod = CtNewMethod.getter("getRpcUrl", rpcUrlField);
        getClientMethod.setModifiers(Modifier.PUBLIC | Modifier.FINAL);
        result.addMethod(getUrlMethod);
    }
    //now generate methods
    ClassInfo<?> classInfo = metadata.computeIfAbsent(clazz, this::getMeta);
    for (Entry<String, MethodInfo> methodData : classInfo.methods.entrySet()) {
        System.out.println("Implementing " + methodData.getKey());
        MethodInfo methodInfo = methodData.getValue();
        Method method = methodInfo.method;
        CtClass returnType = getCt(method.getReturnType());
        //build param array
        CtClass[] params = new CtClass[methodInfo.params.size()];
        int i = 0;
        for (ParamInfo param : methodInfo.params.values()) params[i++] = getCt((Class<?>) param.type.getType());
        StringBuilder methodBody = new StringBuilder("{\n");
        String preparserSignature = methodInfo.annotation.preparser();
        String postparserSignature = methodInfo.annotation.postparser();
        if (preparserSignature != null && !preparserSignature.isEmpty()) {
            String preparserName = preparserSignature;
            String[] preparserArgs = null;
            String[] preparserExceptions = null;
            CtClass ownerClass = clazzCt;
            int idxToken;
            if ((idxToken = preparserName.indexOf("#")) > 0 || (idxToken = preparserName.indexOf(".")) > 0) {
                ownerClass = getCt(preparserName.substring(0, idxToken));
                preparserName = preparserName.substring(idxToken);
            }
            if ((idxToken = preparserName.indexOf("throws")) > 0) {
                String exceptionsText = preparserName.substring(idxToken + 6).trim();
                preparserExceptions = exceptionsText.split(",");
                preparserName.substring(0, idxToken);
            }
            if ((idxToken = preparserName.indexOf('(')) > 0) {
                String preparserArgsText = preparserName.substring(idxToken, '(');
                preparserName = preparserName.substring(0, idxToken);
                if ((idxToken = preparserArgsText.indexOf(")")) > 0)
                    preparserArgsText = preparserArgsText.substring(0, idxToken);
                //TODO fix for generics
                preparserArgs = preparserArgsText.split(",");
            }
            System.out.println("Preparser name: " + preparserName);
            System.out.println("Preparser args: " + Arrays.toString(preparserArgs));
            System.out.println("Preparser exceptions: " + Arrays.toString(preparserExceptions));
            System.out.println("Preparser owner: " + ownerClass);
            //get preparser
            for (Method declared : clazz.getDeclaredMethods()) if (declared.getName().equals(preparserName))
                methodBody.append("org.json.JSONObject params = $0");
        } else {
            //try to build JSONObject from params
        }
        CtMethod generatedOverride = CtNewMethod.make(method.getModifiers(), returnType, method.getName(), params, new CtClass[] {}, methodBody.toString(), result);
        result.addMethod(generatedOverride);
    }
    return result.toClass();
}

[Buggy Hunk]
params[i++] = getCt((Class<?>) param.type.getType());

[Patch]
params[i++] = getCt(param.type);

[Demonstration 3]

[Buggy Method]
private void setDesc(String desc) {
    TextView post_desc = (TextView) mView.findViewById(R.id.post_desc);
    post_desc.setText(desc);
}

[Buggy Hunk]
private void setDesc(String desc) {

[Patch]
public void setDesc(String desc) {