[Demonstration 1]

[Buggy Method]
@Override
public ActionResult<ItemStack> onItemRightClick(ItemStack itemStackIn, World worldIn, EntityPlayer playerIn, EnumHand hand) {
    RayTraceResult raytraceresult = this.rayTrace(worldIn, playerIn, true);
    if (raytraceresult == null) {
        return new ActionResult(EnumActionResult.PASS, itemStackIn);
    } else {
        if (raytraceresult.typeOfHit == RayTraceResult.Type.BLOCK) {
            BlockPos blockpos = raytraceresult.getBlockPos();
            if (!worldIn.isBlockModifiable(playerIn, blockpos) || !playerIn.canPlayerEdit(blockpos.offset(raytraceresult.sideHit), raytraceresult.sideHit, itemStackIn)) {
                return new ActionResult(EnumActionResult.PASS, itemStackIn);
            }
            if (worldIn.getBlockState(blockpos).getMaterial() == Material.WATER) {
                worldIn.playSound(playerIn, playerIn.posX, playerIn.posY, playerIn.posZ, SoundEvents.ITEM_BOTTLE_FILL, SoundCategory.NEUTRAL, 1.0F, 1.0F);
                return new ActionResult(EnumActionResult.SUCCESS, this.turnKettleIntoItem(itemStackIn, playerIn, new ItemStack(BlockLoader.empty_kettle, 1, 4)));
            }
        }
        return new ActionResult(EnumActionResult.PASS, itemStackIn);
    }
}

[Buggy Hunk]
return new ActionResult(EnumActionResult.SUCCESS, this.turnKettleIntoItem(itemStackIn, playerIn, new ItemStack(BlockLoader.empty_kettle, 1, 4)));

[Patch]
return new ActionResult(EnumActionResult.SUCCESS, new ItemStack(BlockLoader.empty_kettle, 1, 4));

[Demonstration 2]

[Buggy Method]
private synchronized void findSymbols(IProgressMonitor monitor, ProjectSettings projectSettings) {
    if (symbols != null) {
        return;
    }
    final List<TapestryModule> modules = modules();
    monitor.beginTask("Resolving symbol providers", modules.size());
    final Orderer<TapestryService> orderer = new Orderer<TapestryService>();
    for (final TapestryModule module : modules) {
        monitor.subTask(module.getModuleClass().getFullyQualifiedName());
        List<Orderable<TapestryService>> symbolProviders = module.symbolProviders(monitor);
        for (Orderable<TapestryService> orderable : symbolProviders) {
            orderer.add(orderable);
        }
        monitor.worked(1);
    }
    final List<TapestryService> symbolProviders = orderer.getOrdered();
    monitor.beginTask("Resolving symbols", modules.size());
    final Map<TapestryService, List<TapestrySymbol>> providersToSymbols = new HashMap<TapestryService, List<TapestrySymbol>>();
    for (final TapestryModule module : modules) {
        monitor.subTask(module.getModuleClass().getFullyQualifiedName());
        module.buildProvidersToSymbolsMap(symbolProviders, monitor);
        for (final TapestryService symbolProvider : symbolProviders) {
            //  Values from the same provider may override each other
            List<TapestrySymbol> providerSymbols = module.symbolsFrom(symbolProvider, monitor);
            if (providerSymbols != null) {
                for (int i = 0; i < providerSymbols.size(); i++) {
                    TapestrySymbol symbol = providerSymbols.get(i);
                    for (int j = i + 1; j < providerSymbols.size(); j++) {
                        TapestrySymbol other = providerSymbols.get(j);
                        if (StringUtils.equals(symbol.getName(), other.getName())) {
                            if (other.isOverride()) {
                                //  Clone symbol to keep cached version untouched
                                symbol = symbol.clone();
                                symbol.setOverridden(true);
                                providerSymbols.set(i, symbol);
                            }
                        }
                    }
                }
                List<TapestrySymbol> symbols = providersToSymbols.get(symbolProvider);
                if (symbols == null) {
                    symbols = new ArrayList<TapestrySymbol>();
                    providersToSymbols.put(symbolProvider, symbols);
                }
                symbols.addAll(providerSymbols);
            }
        }
        monitor.worked(1);
    }
    // Override symbols using values from project settings
    Map<String, TapestryService> symbolProvidersLookup = new CaseInsensitiveMap<>();
    for (TapestryService symbolProvider : symbolProviders) {
        symbolProvidersLookup.put(symbolProvider.getDefinition().getId(), symbolProvider);
    }
    for (Entry<String, Map<String, String>> additionalProviderSymbols : projectSettings.getSymbols().entrySet()) {
        String providerName = additionalProviderSymbols.getKey();
        TapestryService symbolProvider = symbolProvidersLookup.get(providerName);
        if (symbolProvider == null) {
            Activator.getDefault().logWarning("Symbol provider '" + providerName + "' not found");
            continue;
        }
        List<TapestrySymbol> symbols = providersToSymbols.get(symbolProvider);
        if (symbols == null) {
            symbols = new ArrayList<TapestrySymbol>();
            providersToSymbols.put(symbolProvider, symbols);
        }
        Map<String, String> additionalSymbols = additionalProviderSymbols.getValue();
        for (Entry<String, String> symbolEntry : additionalSymbols.entrySet()) {
            // Add to the top of the list to win during symbol expansion
            symbols.add(0, new TapestrySymbol(symbolEntry.getKey(), symbolEntry.getValue(), false, new ProjectSettingsReference(projectSettings), symbolProvider));
        }
    }
    symbols = new HashMap<String, List<TapestrySymbol>>();
    //  Symbol providers ordered by override rule,
    //  symbols in the first provider override values of the second,
    //  second overrides third, etc.
    for (TapestryService symbolProvider : symbolProviders) {
        List<TapestrySymbol> providerSymbols = providersToSymbols.get(symbolProvider);
        if (providerSymbols != null) {
            for (TapestrySymbol symbol : providerSymbols) {
                List<TapestrySymbol> values = symbols.get(symbol.getName());
                if (values == null) {
                    values = new ArrayList<TapestrySymbol>();
                    symbols.put(symbol.getName(), values);
                } else {
                    for (TapestrySymbol existing : values) {
                        if (!existing.isOverridden() && !(existing.getReference() instanceof ProjectSettingsReference) && //  Some modules may be added conditionally, like QA/DEV/Production
                        //  we should treat them all as equal, they souldn't override each other,
                        //  because usually only one of them enabled at run-time
                        !existing.getReference().getTapestryModule().isConditional()) {
                            //  Clone symbol to keep cached version untouched
                            symbol = symbol.clone();
                            symbol.setOverridden(true);
                            break;
                        }
                    }
                }
                values.add(symbol);
            }
        }
    }
}

[Buggy Hunk]
Map<String, TapestryService> symbolProvidersLookup = new CaseInsensitiveMap<>();

[Patch]
Map<String, TapestryService> symbolProvidersLookup = new CaseInsensitiveMap<TapestryService>();

[Demonstration 3]

[Buggy Method]
@Override
public ActionResult<ItemStack> onItemRightClick(ItemStack itemStackIn, World worldIn, EntityPlayer playerIn, EnumHand hand) {
    super.onItemRightClick(itemStackIn, worldIn, playerIn, hand);
    //worldIn.playSoundAtEntity(playerIn, "kalstuff:item.closedSoda.open", 1.0f, 1.0f);
    worldIn.playSound(playerIn, playerIn.posX, playerIn.posY, playerIn.posZ, ModSoundEvents.item_soda_can_open, SoundCategory.PLAYERS, 1.0F, 1.0F);
    --itemStackIn.stackSize;
    if (itemStackIn.stackSize <= 0)
        return new ActionResult<ItemStack>(EnumActionResult.SUCCESS, new ItemStack(this.item));
    playerIn.inventory.addItemStackToInventory(new ItemStack(this.item));
    return new ActionResult<ItemStack>(EnumActionResult.SUCCESS, itemStackIn);
}

[Buggy Hunk]
worldIn.playSound(playerIn, playerIn.posX, playerIn.posY, playerIn.posZ, ModSoundEvents.item_soda_can_open, SoundCategory.PLAYERS, 1.0F, 1.0F);

[Patch]
playerIn.worldObj.playSound(playerIn, playerIn.posX, playerIn.posY, playerIn.posZ, ModSoundEvents.CAN_OPEN, SoundCategory.PLAYERS, 1.0F, 1.0F);