Merge the @Singular feature and the fix for ecj and the shadowloader.

10 files changed, 765 insertions, 469 deletions

diff --git a/src/core/lombok/bytecode/PostCompilerApp.java b/src/core/lombok/bytecode/PostCompilerApp.java
index d2c3157c..5f49bd81 100644
--- a/src/core/lombok/bytecode/PostCompilerApp.java
+++ b/src/core/lombok/bytecode/PostCompilerApp.java
@@ -98,7 +98,7 @@ public class PostCompilerApp extends LombokApp {
 			byte[] original = readFile(file);
 			byte[] clone = original.clone();
 			byte[] transformed = PostCompiler.applyTransformations(clone, file.toString(), DiagnosticsReceiver.CONSOLE);
-			if (clone != transformed && !Arrays.equals(clone, transformed)) {
+			if (clone != transformed && !Arrays.equals(original, transformed)) {
 				filesTouched++;
 				if (args.verbose) System.out.println("Rewriting " + file.getAbsolutePath());
 				writeFile(file, transformed);
@@ -138,18 +138,24 @@ public class PostCompilerApp extends LombokApp {
 		byte[] buffer = new byte[1024];
 		ByteArrayOutputStream bytes = new ByteArrayOutputStream();
 		FileInputStream fileInputStream = new FileInputStream(file);
-		while (true) {
-			int read = fileInputStream.read(buffer);
-			if (read == -1) break;
-			bytes.write(buffer, 0, read);
+		try {
+			while (true) {
+				int read = fileInputStream.read(buffer);
+				if (read == -1) break;
+				bytes.write(buffer, 0, read);
+			}
+		} finally {
+			fileInputStream.close();
 		}
-		fileInputStream.close();
 		return bytes.toByteArray();
 	}
 	
 	static void writeFile(File file, byte[] transformed) throws IOException {
 		FileOutputStream out = new FileOutputStream(file);
-		out.write(transformed);
-		out.close();
+		try {
+			out.write(transformed);
+		} finally {
+			out.close();
+		}
 	}
 }
diff --git a/src/core/lombok/core/Main.java b/src/core/lombok/core/Main.java
index 0856d3b3..dc613b0d 100644
--- a/src/core/lombok/core/Main.java
+++ b/src/core/lombok/core/Main.java
@@ -143,7 +143,7 @@ public class Main {
 			out.println("------------------------------");
 		}
 		out.println("projectlombok.org " + Version.getFullVersion());
-		out.println("Copyright (C) 2009-2012 The Project Lombok Authors.");
+		out.println("Copyright (C) 2009-2015 The Project Lombok Authors.");
 		out.println("Run 'lombok license' to see the lombok license agreement.");
 		out.println();
 		out.println("Run lombok without any parameters to start the graphical installer.");
diff --git a/src/delombok/lombok/delombok/Delombok.java b/src/delombok/lombok/delombok/Delombok.java
index f64e36a1..059bb004 100644
--- a/src/delombok/lombok/delombok/Delombok.java
+++ b/src/delombok/lombok/delombok/Delombok.java
@@ -509,7 +509,7 @@ public class Delombok {
 			DelombokResult result = new DelombokResult(catcher.getComments(unit), unit, force || options.isChanged(unit), fps);
 			if (verbose) feedback.printf("File: %s [%s]\n", unit.sourcefile.getName(), result.isChanged() ? "delomboked" : "unchanged");
 			Writer rawWriter;
-			if (presetWriter != null) rawWriter = presetWriter;
+			if (presetWriter != null) rawWriter = createUnicodeEscapeWriter(presetWriter);
 			else if (output == null) rawWriter = createStandardOutWriter();
 			else rawWriter = createFileWriter(output, baseMap.get(unit), unit.sourcefile.toUri());
 			BufferedWriter writer = new BufferedWriter(rawWriter);
@@ -605,6 +605,10 @@ public class Delombok {
 		return createUnicodeEscapeWriter(System.out);
 	}
 	
+	private Writer createUnicodeEscapeWriter(Writer writer) {
+		return new UnicodeEscapeWriter(writer, charset);
+	}
+	
 	private Writer createUnicodeEscapeWriter(OutputStream out) {
 		return new UnicodeEscapeWriter(new OutputStreamWriter(out, charset), charset);
 	}
diff --git a/src/delombok/lombok/delombok/PrettyCommentsPrinter.java b/src/delombok/lombok/delombok/PrettyCommentsPrinter.java
index 9dd7e40e..72a8ff59 100644
--- a/src/delombok/lombok/delombok/PrettyCommentsPrinter.java
+++ b/src/delombok/lombok/delombok/PrettyCommentsPrinter.java
@@ -104,7 +104,6 @@ import com.sun.tools.javac.tree.JCTree.LetExpr;
 import com.sun.tools.javac.tree.JCTree.TypeBoundKind;
 import com.sun.tools.javac.tree.TreeInfo;
 import com.sun.tools.javac.tree.TreeScanner;
-import com.sun.tools.javac.util.Convert;
 import com.sun.tools.javac.util.List;
 import com.sun.tools.javac.util.Name;
 import com.sun.tools.javac.util.Position;
@@ -209,7 +208,6 @@ public class PrettyCommentsPrinter extends JCTree.Visitor {
 	
 	private void consumeComments(int until, JCTree tree) throws IOException {
 		boolean prevNewLine = onNewLine;
-		boolean found = false;
 		CommentInfo head = comments.head;
 		while (comments.nonEmpty() && head.pos < until) {
 			printComment(head);
@@ -355,7 +353,7 @@ public class PrettyCommentsPrinter extends JCTree.Visitor {
 		}
 		needsSpace = false;
 		
-		out.write(Convert.escapeUnicode(s.toString()));
+		out.write(s.toString());
 		
 		onNewLine = false;
 		aligned = false;
@@ -1413,16 +1411,51 @@ public class PrettyCommentsPrinter extends JCTree.Visitor {
 			else if (CTC_FLOAT.equals(typeTag)) print(tree.value + "F");
 			else if (CTC_DOUBLE.equals(typeTag)) print(tree.value.toString());
 			else if (CTC_CHAR.equals(typeTag)) {
-				print("\'" + Convert.quote(String.valueOf((char)((Number)tree.value).intValue())) + "\'");
+				print("\'" + quoteChar((char)((Number)tree.value).intValue()) + "\'");
 			}
 			else if (CTC_BOOLEAN.equals(typeTag)) print(((Number)tree.value).intValue() == 1 ? "true" : "false");
 			else if (CTC_BOT.equals(typeTag)) print("null");
-			else print("\"" + Convert.quote(tree.value.toString()) + "\"");
+			else print("\"" + quoteChars(tree.value.toString()) + "\"");
 		} catch (IOException e) {
 			throw new UncheckedIOException(e);
 		}
 	}
 	
+	public static String quoteChars(String s) {
+		StringBuilder buf = new StringBuilder();
+		for (int i = 0; i < s.length(); i++) {
+			buf.append(quoteChar(s.charAt(i)));
+		}
+		return buf.toString();
+	}
+	
+	/**
+	 * Escapes a character if it has an escape sequence or is non-printable
+	 * ASCII. Leaves non-ASCII characters alone.
+	 */
+	public static String quoteChar(char ch) {
+		switch (ch) {
+		case '\b':
+			return "\\b";
+		case '\f':
+			return "\\f";
+		case '\n':
+			return "\\n";
+		case '\r':
+			return "\\r";
+		case '\t':
+			return "\\t";
+		case '\'':
+			return "\\'";
+		case '\"':
+			return "\\\"";
+		case '\\':
+			return "\\\\";
+		default:
+			return ch < 32 ? String.format("\\%03o", (int) ch) : String.valueOf(ch);
+		}
+	}
+	
 	public void visitTypeIdent(JCPrimitiveTypeTree tree) {
 		TypeTag typetag = typeTag(tree);
 		try {
diff --git a/src/delombok/lombok/delombok/UnicodeEscapeWriter.java b/src/delombok/lombok/delombok/UnicodeEscapeWriter.java
index 95b55078..9c2ef190 100644
--- a/src/delombok/lombok/delombok/UnicodeEscapeWriter.java
+++ b/src/delombok/lombok/delombok/UnicodeEscapeWriter.java
@@ -63,6 +63,6 @@ public class UnicodeEscapeWriter extends Writer {
 	}
 	
 	protected void writeUnicodeEscape(char c) throws IOException {
-		writer.write("\\u" + Integer.toHexString(c));
+		writer.write(String.format("\\u%04x", (int) c));
 	}
 }
\ No newline at end of file
diff --git a/src/eclipseAgent/lombok/eclipse/agent/EclipsePatcher.java b/src/eclipseAgent/lombok/eclipse/agent/EclipsePatcher.java
index 96f253f2..efc7ce94 100644
--- a/src/eclipseAgent/lombok/eclipse/agent/EclipsePatcher.java
+++ b/src/eclipseAgent/lombok/eclipse/agent/EclipsePatcher.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2009-2012 The Project Lombok Authors.
+ * Copyright (C) 2009-2015 The Project Lombok Authors.
  * 
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -76,9 +76,6 @@ public class EclipsePatcher implements AgentLauncher.AgentLaunchable {
 		sm.registerTransformer(instrumentation);
 		if (!ecjOnly) {
 			EclipseLoaderPatcher.patchEquinoxLoaders(sm, launchingContext);
-		}
-		
-		if (!ecjOnly) {
 			patchCatchReparse(sm);
 			patchIdentifierEndReparse(sm);
 			patchRetrieveEllipsisStartPosition(sm);
@@ -112,7 +109,7 @@ public class EclipsePatcher implements AgentLauncher.AgentLaunchable {
 		sm.addScript(ScriptBuilder.wrapMethodCall()
 				.target(new MethodTarget("org.eclipse.jdt.internal.compiler.SourceElementNotifier", "notifySourceElementRequestor", "void", "org.eclipse.jdt.internal.compiler.ast.AbstractMethodDeclaration", "org.eclipse.jdt.internal.compiler.ast.TypeDeclaration", "org.eclipse.jdt.internal.compiler.ast.ImportReference"))
 				.methodToWrap(new Hook("org.eclipse.jdt.internal.compiler.util.HashtableOfObjectToInt", "get", "int", "java.lang.Object"))
-				.wrapMethod(new Hook("lombok.eclipse.agent.PatchFixes", "getSourceEndFixed", "int", "int", "org.eclipse.jdt.internal.compiler.ast.ASTNode"))
+				.wrapMethod(new Hook("lombok.launch.PatchFixesHider$PatchFixes", "getSourceEndFixed", "int", "int", "org.eclipse.jdt.internal.compiler.ast.ASTNode"))
 				.requestExtra(StackRequest.PARAM1)
 				.transplant().build());
 		
@@ -125,7 +122,7 @@ public class EclipsePatcher implements AgentLauncher.AgentLaunchable {
 				"org.eclipse.jdt.core.dom.MethodDeclaration"
 			))
 			.methodToWrap(new Hook("org.eclipse.jface.text.IDocument", "get", "java.lang.String", "int", "int"))
-			.wrapMethod(new Hook("lombok.eclipse.agent.PatchFixes", "getRealMethodDeclarationSource", "java.lang.String", "java.lang.String", "java.lang.Object", "org.eclipse.jdt.core.dom.MethodDeclaration"))
+			.wrapMethod(new Hook("lombok.launch.PatchFixesHider$PatchFixes", "getRealMethodDeclarationSource", "java.lang.String", "java.lang.String", "java.lang.Object", "org.eclipse.jdt.core.dom.MethodDeclaration"))
 			.requestExtra(StackRequest.THIS, StackRequest.PARAM4)
 			.transplant().build());
 		
@@ -134,20 +131,20 @@ public class EclipsePatcher implements AgentLauncher.AgentLaunchable {
 				.target(new MethodTarget("org.eclipse.jdt.internal.corext.refactoring.structure.ExtractInterfaceProcessor", "createMemberDeclarations"))
 				.target(new MethodTarget("org.eclipse.jdt.internal.corext.refactoring.structure.ExtractInterfaceProcessor", "createMethodComments"))
 				.methodToReplace(new Hook("org.eclipse.jdt.internal.corext.refactoring.structure.ASTNodeSearchUtil", "getMethodDeclarationNode", "org.eclipse.jdt.core.dom.MethodDeclaration", "org.eclipse.jdt.core.IMethod", "org.eclipse.jdt.core.dom.CompilationUnit"))
-				.replacementMethod(new Hook("lombok.eclipse.agent.PatchFixes", "getRealMethodDeclarationNode", "org.eclipse.jdt.core.dom.MethodDeclaration", "org.eclipse.jdt.core.IMethod", "org.eclipse.jdt.core.dom.CompilationUnit"))
+				.replacementMethod(new Hook("lombok.launch.PatchFixesHider$PatchFixes", "getRealMethodDeclarationNode", "org.eclipse.jdt.core.dom.MethodDeclaration", "org.eclipse.jdt.core.IMethod", "org.eclipse.jdt.core.dom.CompilationUnit"))
 				.transplant().build());
 		
 		/* Do not add @Override's for generated methods */
 		sm.addScript(ScriptBuilder.exitEarly()
 				.target(new MethodTarget("org.eclipse.jdt.core.dom.rewrite.ListRewrite", "insertFirst"))
-				.decisionMethod(new Hook("lombok.eclipse.agent.PatchFixes", "isListRewriteOnGeneratedNode", "boolean", "org.eclipse.jdt.core.dom.rewrite.ListRewrite"))
+				.decisionMethod(new Hook("lombok.launch.PatchFixesHider$PatchFixes", "isListRewriteOnGeneratedNode", "boolean", "org.eclipse.jdt.core.dom.rewrite.ListRewrite"))
 				.request(StackRequest.THIS)
 				.transplant().build());
 		
 		/* Do not add comments for generated methods */
 		sm.addScript(ScriptBuilder.exitEarly()
 				.target(new MethodTarget("org.eclipse.jdt.internal.corext.refactoring.structure.ExtractInterfaceProcessor", "createMethodComment"))
-				.decisionMethod(new Hook("lombok.eclipse.agent.PatchFixes", "isGenerated", "boolean", "org.eclipse.jdt.core.dom.ASTNode"))
+				.decisionMethod(new Hook("lombok.launch.PatchFixesHider$PatchFixes", "isGenerated", "boolean", "org.eclipse.jdt.core.dom.ASTNode"))
 				.request(StackRequest.PARAM2)
 				.transplant().build());
 	}
@@ -160,7 +157,7 @@ public class EclipsePatcher implements AgentLauncher.AgentLaunchable {
 		 */
 		sm.addScript(ScriptBuilder.wrapReturnValue()
 				.target(new MethodTarget("org.eclipse.core.internal.runtime.Product", "getProperty", "java.lang.String", "java.lang.String"))
-				.wrapMethod(new Hook("lombok.eclipse.agent.PatchFixes", "addLombokNotesToEclipseAboutDialog", "java.lang.String", "java.lang.String", "java.lang.String"))
+				.wrapMethod(new Hook("lombok.launch.PatchFixesHider$LombokDeps", "addLombokNotesToEclipseAboutDialog", "java.lang.String", "java.lang.String", "java.lang.String"))
 				.request(StackRequest.RETURN_VALUE, StackRequest.PARAM1)
 				.transplant().build());
 	}
@@ -173,8 +170,8 @@ public class EclipsePatcher implements AgentLauncher.AgentLaunchable {
 				.target(new MethodTarget("org.eclipse.jdt.internal.ui.search.OccurrencesFinder", "addUsage"))
 				.target(new MethodTarget("org.eclipse.jdt.internal.ui.search.OccurrencesFinder", "addWrite"))
 				.target(new MethodTarget("org.eclipse.jdt.internal.ui.javaeditor.SemanticHighlightingReconciler$PositionCollector", "visit", "boolean", "org.eclipse.jdt.core.dom.SimpleName"))
-				.decisionMethod(new Hook("lombok.eclipse.agent.PatchFixes", "isGenerated", "boolean", "org.eclipse.jdt.core.dom.ASTNode"))
-				.valueMethod(new Hook("lombok.eclipse.agent.PatchFixes", "returnFalse", "boolean", "java.lang.Object"))
+				.decisionMethod(new Hook("lombok.launch.PatchFixesHider$PatchFixes", "isGenerated", "boolean", "org.eclipse.jdt.core.dom.ASTNode"))
+				.valueMethod(new Hook("lombok.launch.PatchFixesHider$PatchFixes", "returnFalse", "boolean", "java.lang.Object"))
 				.request(StackRequest.PARAM1)
 				.build());
 	}
@@ -199,9 +196,9 @@ public class EclipsePatcher implements AgentLauncher.AgentLaunchable {
 			.target(new MethodTarget("org.eclipse.jdt.internal.corext.fix.CodeStyleFix$CodeStyleVisitor", "visit", "boolean", "org.eclipse.jdt.core.dom.QualifiedName"))
 			.target(new MethodTarget("org.eclipse.jdt.internal.corext.fix.CodeStyleFix$CodeStyleVisitor", "visit", "boolean", "org.eclipse.jdt.core.dom.SimpleName"))
 			// if a generated node has children we can just ignore them as well;
-			.decisionMethod(new Hook("lombok.eclipse.agent.PatchFixes", "isGenerated", "boolean", "org.eclipse.jdt.core.dom.ASTNode"))
+			.decisionMethod(new Hook("lombok.launch.PatchFixesHider$PatchFixes", "isGenerated", "boolean", "org.eclipse.jdt.core.dom.ASTNode"))
 			.request(StackRequest.PARAM1)
-			.valueMethod(new Hook("lombok.eclipse.agent.PatchFixes", "returnFalse", "boolean", "java.lang.Object"))
+			.valueMethod(new Hook("lombok.launch.PatchFixesHider$PatchFixes", "returnFalse", "boolean", "java.lang.Object"))
 			.build());
 	}
 	
@@ -209,7 +206,7 @@ public class EclipsePatcher implements AgentLauncher.AgentLaunchable {
 		sm.addScript(ScriptBuilder.replaceMethodCall()
 				.target(new MethodTarget("org.eclipse.jdt.internal.core.dom.rewrite.ASTRewriteAnalyzer$ListRewriter", "rewriteList"))
 				.methodToReplace(new Hook("org.eclipse.jdt.internal.core.dom.rewrite.RewriteEvent", "getChildren", "org.eclipse.jdt.internal.core.dom.rewrite.RewriteEvent[]"))
-				.replacementMethod(new Hook("lombok.eclipse.agent.PatchFixes", "listRewriteHandleGeneratedMethods", "org.eclipse.jdt.internal.core.dom.rewrite.RewriteEvent[]", "org.eclipse.jdt.internal.core.dom.rewrite.RewriteEvent"))
+				.replacementMethod(new Hook("lombok.launch.PatchFixesHider$PatchFixes", "listRewriteHandleGeneratedMethods", "org.eclipse.jdt.internal.core.dom.rewrite.RewriteEvent[]", "org.eclipse.jdt.internal.core.dom.rewrite.RewriteEvent"))
 				.build());
 	}
 
@@ -221,37 +218,37 @@ public class EclipsePatcher implements AgentLauncher.AgentLaunchable {
 		sm.addScript(ScriptBuilder.wrapMethodCall()
 				.target(new MethodTarget("org.eclipse.jdt.internal.core.SortElementsOperation$2", "visit", "boolean", "org.eclipse.jdt.core.dom.CompilationUnit"))
 				.methodToWrap(new Hook("org.eclipse.jdt.core.dom.CompilationUnit", "types", "java.util.List"))
-				.wrapMethod(new Hook("lombok.eclipse.agent.PatchFixes", "removeGeneratedNodes", "java.util.List", "java.util.List"))
+				.wrapMethod(new Hook("lombok.launch.PatchFixesHider$PatchFixes", "removeGeneratedNodes", "java.util.List", "java.util.List"))
 				.transplant().build());
 		
 		sm.addScript(ScriptBuilder.wrapMethodCall()
 				.target(new MethodTarget("org.eclipse.jdt.internal.core.SortElementsOperation$2", "visit", "boolean", "org.eclipse.jdt.core.dom.AnnotationTypeDeclaration"))
 				.methodToWrap(new Hook("org.eclipse.jdt.core.dom.AnnotationTypeDeclaration", "bodyDeclarations", "java.util.List"))
-				.wrapMethod(new Hook("lombok.eclipse.agent.PatchFixes", "removeGeneratedNodes", "java.util.List", "java.util.List"))
+				.wrapMethod(new Hook("lombok.launch.PatchFixesHider$PatchFixes", "removeGeneratedNodes", "java.util.List", "java.util.List"))
 				.transplant().build());
 		
 		sm.addScript(ScriptBuilder.wrapMethodCall()
 				.target(new MethodTarget("org.eclipse.jdt.internal.core.SortElementsOperation$2", "visit", "boolean", "org.eclipse.jdt.core.dom.AnonymousClassDeclaration"))
 				.methodToWrap(new Hook("org.eclipse.jdt.core.dom.AnonymousClassDeclaration", "bodyDeclarations", "java.util.List"))
-				.wrapMethod(new Hook("lombok.eclipse.agent.PatchFixes", "removeGeneratedNodes", "java.util.List", "java.util.List"))
+				.wrapMethod(new Hook("lombok.launch.PatchFixesHider$PatchFixes", "removeGeneratedNodes", "java.util.List", "java.util.List"))
 				.transplant().build());
 		
 		sm.addScript(ScriptBuilder.wrapMethodCall()
 				.target(new MethodTarget("org.eclipse.jdt.internal.core.SortElementsOperation$2", "visit", "boolean", "org.eclipse.jdt.core.dom.TypeDeclaration"))
 				.methodToWrap(new Hook("org.eclipse.jdt.core.dom.TypeDeclaration", "bodyDeclarations", "java.util.List"))
-				.wrapMethod(new Hook("lombok.eclipse.agent.PatchFixes", "removeGeneratedNodes", "java.util.List", "java.util.List"))
+				.wrapMethod(new Hook("lombok.launch.PatchFixesHider$PatchFixes", "removeGeneratedNodes", "java.util.List", "java.util.List"))
 				.transplant().build());
 		
 		sm.addScript(ScriptBuilder.wrapMethodCall()
 				.target(new MethodTarget("org.eclipse.jdt.internal.core.SortElementsOperation$2", "visit", "boolean", "org.eclipse.jdt.core.dom.EnumDeclaration"))
 				.methodToWrap(new Hook("org.eclipse.jdt.core.dom.EnumDeclaration", "bodyDeclarations", "java.util.List"))
-				.wrapMethod(new Hook("lombok.eclipse.agent.PatchFixes", "removeGeneratedNodes", "java.util.List", "java.util.List"))
+				.wrapMethod(new Hook("lombok.launch.PatchFixesHider$PatchFixes", "removeGeneratedNodes", "java.util.List", "java.util.List"))
 				.transplant().build());
 		
 		sm.addScript(ScriptBuilder.wrapMethodCall()
 				.target(new MethodTarget("org.eclipse.jdt.internal.core.SortElementsOperation$2", "visit", "boolean", "org.eclipse.jdt.core.dom.EnumDeclaration"))
 				.methodToWrap(new Hook("org.eclipse.jdt.core.dom.EnumDeclaration", "enumConstants", "java.util.List"))
-				.wrapMethod(new Hook("lombok.eclipse.agent.PatchFixes", "removeGeneratedNodes", "java.util.List", "java.util.List"))
+				.wrapMethod(new Hook("lombok.launch.PatchFixesHider$PatchFixes", "removeGeneratedNodes", "java.util.List", "java.util.List"))
 				.transplant().build());
 	}
 	
@@ -259,7 +256,7 @@ public class EclipsePatcher implements AgentLauncher.AgentLaunchable {
 		sm.addScript(ScriptBuilder.replaceMethodCall()
 				.target(new MethodTarget("org.eclipse.jdt.internal.core.dom.rewrite.ASTRewriteAnalyzer", "visit"))
 				.methodToReplace(new Hook("org.eclipse.jdt.internal.core.dom.rewrite.TokenScanner", "getTokenEndOffset", "int", "int", "int"))
-				.replacementMethod(new Hook("lombok.eclipse.agent.PatchFixes", "getTokenEndOffsetFixed", "int", "org.eclipse.jdt.internal.core.dom.rewrite.TokenScanner", "int", "int", "java.lang.Object"))
+				.replacementMethod(new Hook("lombok.launch.PatchFixesHider$PatchFixes", "getTokenEndOffsetFixed", "int", "org.eclipse.jdt.internal.core.dom.rewrite.TokenScanner", "int", "int", "java.lang.Object"))
 				.requestExtra(StackRequest.PARAM1)
 				.transplant()
 				.build());
@@ -271,7 +268,7 @@ public class EclipsePatcher implements AgentLauncher.AgentLaunchable {
 				.target(new MethodTarget("org.eclipse.jdt.internal.core.builder.IncrementalImageBuilder", "writeClassFileContents"))
 				.target(new MethodTarget("org.eclipse.jdt.internal.core.builder.AbstractImageBuilder", "writeClassFileContents"))
 				.methodToWrap(new Hook("org.eclipse.jdt.internal.compiler.ClassFile", "getBytes", "byte[]"))
-				.wrapMethod(new Hook("lombok.eclipse.agent.PatchFixes", "runPostCompiler", "byte[]", "byte[]", "java.lang.String"))
+				.wrapMethod(new Hook("lombok.launch.PatchFixesHider$LombokDeps", "runPostCompiler", "byte[]", "byte[]", "java.lang.String"))
 				.requestExtra(StackRequest.PARAM3)
 				.build());
 	}
@@ -280,24 +277,22 @@ public class EclipsePatcher implements AgentLauncher.AgentLaunchable {
 		sm.addScript(ScriptBuilder.wrapMethodCall()
 				.target(new MethodTarget("org.eclipse.jdt.internal.compiler.tool.EclipseCompilerImpl", "outputClassFiles"))
 				.methodToWrap(new Hook("javax.tools.JavaFileObject", "openOutputStream", "java.io.OutputStream"))
-				.wrapMethod(new Hook("lombok.eclipse.agent.PatchFixes", "runPostCompiler", "java.io.OutputStream", "java.io.OutputStream"))
-				.transplant()
-				.build());
+				.wrapMethod(new Hook("lombok.launch.PatchFixesHider$LombokDeps", "runPostCompiler", "java.io.OutputStream", "java.io.OutputStream"))
+				.transplant().build());
 		
 		sm.addScript(ScriptBuilder.wrapMethodCall()
 				.target(new MethodTarget("org.eclipse.jdt.internal.compiler.util.Util", "writeToDisk"))
 				.methodToWrap(new Hook("java.io.BufferedOutputStream", "<init>", "void", "java.io.OutputStream", "int"))
-				.wrapMethod(new Hook("lombok.eclipse.agent.PatchFixes", "runPostCompiler", "java.io.BufferedOutputStream", "java.io.BufferedOutputStream", "java.lang.String", "java.lang.String"))
+				.wrapMethod(new Hook("lombok.launch.PatchFixesHider$LombokDeps", "runPostCompiler", "java.io.BufferedOutputStream", "java.io.BufferedOutputStream", "java.lang.String", "java.lang.String"))
 				.requestExtra(StackRequest.PARAM2, StackRequest.PARAM3)
-				.transplant()
-				.build());
+				.transplant().build());
 	}
 	
 	private static void patchHideGeneratedNodes(ScriptManager sm) {
 		sm.addScript(ScriptBuilder.wrapReturnValue()
 				.target(new MethodTarget("org.eclipse.jdt.internal.corext.dom.LinkedNodeFinder", "findByNode"))
 				.target(new MethodTarget("org.eclipse.jdt.internal.corext.dom.LinkedNodeFinder", "findByBinding"))
-				.wrapMethod(new Hook("lombok.eclipse.agent.PatchFixes", "removeGeneratedSimpleNames", "org.eclipse.jdt.core.dom.SimpleName[]",
+				.wrapMethod(new Hook("lombok.launch.PatchFixesHider$PatchFixes", "removeGeneratedSimpleNames", "org.eclipse.jdt.core.dom.SimpleName[]",
 						"org.eclipse.jdt.core.dom.SimpleName[]"))
 				.request(StackRequest.RETURN_VALUE).build());
 		
@@ -317,22 +312,22 @@ public class EclipsePatcher implements AgentLauncher.AgentLaunchable {
 		sm.addScript(ScriptBuilder.exitEarly()
 				.target(new MethodTarget("org.eclipse.jdt.core.dom.rewrite.ASTRewrite", "replace"))
 				.target(new MethodTarget("org.eclipse.jdt.core.dom.rewrite.ASTRewrite", "remove"))
-				.decisionMethod(new Hook("lombok.eclipse.agent.PatchFixes", "skipRewritingGeneratedNodes", "boolean",
+				.decisionMethod(new Hook("lombok.launch.PatchFixesHider$PatchFixes", "skipRewritingGeneratedNodes", "boolean",
 						"org.eclipse.jdt.core.dom.ASTNode"))
 				.transplant().request(StackRequest.PARAM1).build());
 		
 		sm.addScript(ScriptBuilder.wrapMethodCall()
 				.target(new MethodTarget("org.eclipse.jdt.internal.corext.refactoring.rename.RenameTypeProcessor", "addConstructorRenames"))
 				.methodToWrap(new Hook("org.eclipse.jdt.core.IType", "getMethods", "org.eclipse.jdt.core.IMethod[]"))
-				.wrapMethod(new Hook("lombok.eclipse.agent.PatchFixes", "removeGeneratedMethods", "org.eclipse.jdt.core.IMethod[]",
+				.wrapMethod(new Hook("lombok.launch.PatchFixesHider$PatchFixes", "removeGeneratedMethods", "org.eclipse.jdt.core.IMethod[]",
 						"org.eclipse.jdt.core.IMethod[]"))
 				.transplant().build());
 		
 		sm.addScript(ScriptBuilder.exitEarly()
 				.target(new MethodTarget("org.eclipse.jdt.internal.corext.refactoring.rename.TempOccurrenceAnalyzer", "visit", "boolean", "org.eclipse.jdt.core.dom.SimpleName"))
 				.target(new MethodTarget("org.eclipse.jdt.internal.corext.refactoring.rename.RenameAnalyzeUtil$ProblemNodeFinder$NameNodeVisitor", "visit", "boolean", "org.eclipse.jdt.core.dom.SimpleName"))
-				.decisionMethod(new Hook("lombok.eclipse.agent.PatchFixes", "isGenerated", "boolean", "org.eclipse.jdt.core.dom.ASTNode"))
-				.valueMethod(new Hook("lombok.eclipse.agent.PatchFixes", "returnTrue", "boolean", "java.lang.Object"))
+				.decisionMethod(new Hook("lombok.launch.PatchFixesHider$PatchFixes", "isGenerated", "boolean", "org.eclipse.jdt.core.dom.ASTNode"))
+				.valueMethod(new Hook("lombok.launch.PatchFixesHider$PatchFixes", "returnTrue", "boolean", "java.lang.Object"))
 				.request(StackRequest.PARAM1)
 				.transplant().build());
 	}
@@ -340,21 +335,21 @@ public class EclipsePatcher implements AgentLauncher.AgentLaunchable {
 	private static void patchCatchReparse(ScriptManager sm) {
 		sm.addScript(ScriptBuilder.wrapReturnValue()
 				.target(new MethodTarget("org.eclipse.jdt.core.dom.ASTConverter", "retrieveStartingCatchPosition"))
-				.wrapMethod(new Hook("lombok.eclipse.agent.PatchFixes", "fixRetrieveStartingCatchPosition", "int", "int", "int"))
+				.wrapMethod(new Hook("lombok.launch.PatchFixesHider$PatchFixes", "fixRetrieveStartingCatchPosition", "int", "int", "int"))
 				.transplant().request(StackRequest.RETURN_VALUE, StackRequest.PARAM1).build());
 	}
 	
 	private static void patchIdentifierEndReparse(ScriptManager sm) {
 		sm.addScript(ScriptBuilder.wrapReturnValue()
 				.target(new MethodTarget("org.eclipse.jdt.core.dom.ASTConverter", "retrieveIdentifierEndPosition"))
-				.wrapMethod(new Hook("lombok.eclipse.agent.PatchFixes", "fixRetrieveIdentifierEndPosition", "int", "int", "int"))
+				.wrapMethod(new Hook("lombok.launch.PatchFixesHider$PatchFixes", "fixRetrieveIdentifierEndPosition", "int", "int", "int"))
 				.transplant().request(StackRequest.RETURN_VALUE, StackRequest.PARAM2).build());
 	}
 	
 	private static void patchRetrieveEllipsisStartPosition(ScriptManager sm) {
 		sm.addScript(ScriptBuilder.wrapReturnValue()
 				.target(new MethodTarget("org.eclipse.jdt.core.dom.ASTConverter", "retrieveEllipsisStartPosition"))
-				.wrapMethod(new Hook("lombok.eclipse.agent.PatchFixes", "fixRetrieveEllipsisStartPosition", "int", "int", "int"))
+				.wrapMethod(new Hook("lombok.launch.PatchFixesHider$PatchFixes", "fixRetrieveEllipsisStartPosition", "int", "int", "int"))
 				.transplant().request(StackRequest.RETURN_VALUE, StackRequest.PARAM2).build());
 	}
 	
@@ -362,7 +357,7 @@ public class EclipsePatcher implements AgentLauncher.AgentLaunchable {
 		sm.addScript(ScriptBuilder.wrapReturnValue()
 				.target(new MethodTarget("org.eclipse.jdt.core.dom.ASTConverter", "retrieveRightBraceOrSemiColonPosition"))
 				.target(new MethodTarget("org.eclipse.jdt.core.dom.ASTConverter", "retrieveRightBrace"))
-				.wrapMethod(new Hook("lombok.eclipse.agent.PatchFixes", "fixRetrieveRightBraceOrSemiColonPosition", "int", "int", "int"))
+				.wrapMethod(new Hook("lombok.launch.PatchFixesHider$PatchFixes", "fixRetrieveRightBraceOrSemiColonPosition", "int", "int", "int"))
 				.transplant().request(StackRequest.RETURN_VALUE, StackRequest.PARAM2).build());
 	}
 
@@ -394,14 +389,14 @@ public class EclipsePatcher implements AgentLauncher.AgentLaunchable {
 						return Collections.singleton("org.eclipse.jdt.core.dom.ASTConverter");
 					}
 				}).request(StackRequest.PARAM1, StackRequest.RETURN_VALUE)
-				.wrapMethod(new Hook("lombok.eclipse.agent.PatchFixes", "setIsGeneratedFlag", "void",
+				.wrapMethod(new Hook("lombok.launch.PatchFixesHider$PatchFixes", "setIsGeneratedFlag", "void",
 						"org.eclipse.jdt.core.dom.ASTNode", "org.eclipse.jdt.internal.compiler.ast.ASTNode"))
 				.transplant().build());
 		
 		sm.addScript(ScriptBuilder.wrapReturnValue()
 				.target(new MethodTarget("org.eclipse.jdt.core.dom.ASTConverter", "convert", "org.eclipse.jdt.core.dom.ASTNode", "boolean", "org.eclipse.jdt.internal.compiler.ast.AbstractMethodDeclaration"))
 				.request(StackRequest.PARAM2, StackRequest.RETURN_VALUE)
-				.wrapMethod(new Hook("lombok.eclipse.agent.PatchFixes", "setIsGeneratedFlag", "void",
+				.wrapMethod(new Hook("lombok.launch.PatchFixesHider$PatchFixes", "setIsGeneratedFlag", "void",
 						"org.eclipse.jdt.core.dom.ASTNode", "org.eclipse.jdt.internal.compiler.ast.ASTNode"))
 				.transplant().build());
 		
@@ -419,7 +414,7 @@ public class EclipsePatcher implements AgentLauncher.AgentLaunchable {
 				.target(new MethodTarget("org.eclipse.jdt.core.dom.ASTConverter", "convertToVariableDeclarationStatement", "org.eclipse.jdt.core.dom.VariableDeclarationStatement", "org.eclipse.jdt.internal.compiler.ast.LocalDeclaration"))
 /* Targets above are only patched because the resulting dom nodes should be marked if generated. */
 				.request(StackRequest.PARAM1, StackRequest.RETURN_VALUE)
-				.wrapMethod(new Hook("lombok.eclipse.agent.PatchFixes", "setIsGeneratedFlag", "void",
+				.wrapMethod(new Hook("lombok.launch.PatchFixesHider$PatchFixes", "setIsGeneratedFlag", "void",
 						"org.eclipse.jdt.core.dom.ASTNode", "org.eclipse.jdt.internal.compiler.ast.ASTNode"))
 				.transplant().build());
 		
@@ -441,7 +436,7 @@ public class EclipsePatcher implements AgentLauncher.AgentLaunchable {
 					}
 				}).methodToWrap(new Hook("org.eclipse.jdt.core.dom.SimpleName", "<init>", "void", "org.eclipse.jdt.core.dom.AST"))
 				.requestExtra(StackRequest.PARAM1)
-				.wrapMethod(new Hook("lombok.eclipse.agent.PatchFixes", "setIsGeneratedFlagForName", "void",
+				.wrapMethod(new Hook("lombok.launch.PatchFixesHider$PatchFixes", "setIsGeneratedFlagForName", "void",
 						"org.eclipse.jdt.core.dom.Name", "java.lang.Object"))
 				.transplant().build());
 
@@ -449,7 +444,7 @@ public class EclipsePatcher implements AgentLauncher.AgentLaunchable {
 				.target(new MethodTarget("org.eclipse.jdt.core.dom.ASTConverter", "convert", "org.eclipse.jdt.core.dom.ASTNode", "boolean", "org.eclipse.jdt.internal.compiler.ast.AbstractMethodDeclaration"))
 				.methodToWrap(new Hook("org.eclipse.jdt.core.dom.SimpleName", "<init>", "void", "org.eclipse.jdt.core.dom.AST"))
 				.requestExtra(StackRequest.PARAM2)
-				.wrapMethod(new Hook("lombok.eclipse.agent.PatchFixes", "setIsGeneratedFlagForName", "void",
+				.wrapMethod(new Hook("lombok.launch.PatchFixesHider$PatchFixes", "setIsGeneratedFlagForName", "void",
 						"org.eclipse.jdt.core.dom.Name", "java.lang.Object"))
 				.transplant().build());
 
@@ -458,7 +453,7 @@ public class EclipsePatcher implements AgentLauncher.AgentLaunchable {
 				.target(new MethodTarget("org.eclipse.jdt.core.dom.ASTConverter", "setQualifiedNameNameAndSourceRanges", "org.eclipse.jdt.core.dom.QualifiedName", "char[][]", "long[]", "int", "org.eclipse.jdt.internal.compiler.ast.ASTNode"))
 				.methodToWrap(new Hook("org.eclipse.jdt.core.dom.SimpleName", "<init>", "void", "org.eclipse.jdt.core.dom.AST"))
 				.requestExtra(StackRequest.PARAM4)
-				.wrapMethod(new Hook("lombok.eclipse.agent.PatchFixes", "setIsGeneratedFlagForName", "void",
+				.wrapMethod(new Hook("lombok.launch.PatchFixesHider$PatchFixes", "setIsGeneratedFlagForName", "void",
 						"org.eclipse.jdt.core.dom.Name", "java.lang.Object"))
 				.transplant().build());
 
@@ -466,7 +461,7 @@ public class EclipsePatcher implements AgentLauncher.AgentLaunchable {
 				.target(new MethodTarget("org.eclipse.jdt.core.dom.ASTConverter", "setQualifiedNameNameAndSourceRanges", "org.eclipse.jdt.core.dom.QualifiedName", "char[][]", "long[]", "int", "org.eclipse.jdt.internal.compiler.ast.ASTNode"))
 				.methodToWrap(new Hook("org.eclipse.jdt.core.dom.QualifiedName", "<init>", "void", "org.eclipse.jdt.core.dom.AST"))
 				.requestExtra(StackRequest.PARAM4)
-				.wrapMethod(new Hook("lombok.eclipse.agent.PatchFixes", "setIsGeneratedFlagForName", "void",
+				.wrapMethod(new Hook("lombok.launch.PatchFixesHider$PatchFixes", "setIsGeneratedFlagForName", "void",
 						"org.eclipse.jdt.core.dom.Name", "java.lang.Object"))
 				.transplant().build());
 
@@ -474,7 +469,7 @@ public class EclipsePatcher implements AgentLauncher.AgentLaunchable {
 				.target(new MethodTarget("org.eclipse.jdt.core.dom.ASTConverter", "setQualifiedNameNameAndSourceRanges", "org.eclipse.jdt.core.dom.QualifiedName", "char[][]", "long[]", "org.eclipse.jdt.internal.compiler.ast.ASTNode"))
 				.methodToWrap(new Hook("org.eclipse.jdt.core.dom.SimpleName", "<init>", "void", "org.eclipse.jdt.core.dom.AST"))
 				.requestExtra(StackRequest.PARAM3)
-				.wrapMethod(new Hook("lombok.eclipse.agent.PatchFixes", "setIsGeneratedFlagForName", "void",
+				.wrapMethod(new Hook("lombok.launch.PatchFixesHider$PatchFixes", "setIsGeneratedFlagForName", "void",
 						"org.eclipse.jdt.core.dom.Name", "java.lang.Object"))
 				.transplant().build());
 
@@ -482,7 +477,7 @@ public class EclipsePatcher implements AgentLauncher.AgentLaunchable {
 				.target(new MethodTarget("org.eclipse.jdt.core.dom.ASTConverter", "setQualifiedNameNameAndSourceRanges", "org.eclipse.jdt.core.dom.QualifiedName", "char[][]", "long[]", "org.eclipse.jdt.internal.compiler.ast.ASTNode"))
 				.methodToWrap(new Hook("org.eclipse.jdt.core.dom.QualifiedName", "<init>", "void", "org.eclipse.jdt.core.dom.AST"))
 				.requestExtra(StackRequest.PARAM3)
-				.wrapMethod(new Hook("lombok.eclipse.agent.PatchFixes", "setIsGeneratedFlagForName", "void",
+				.wrapMethod(new Hook("lombok.launch.PatchFixesHider$PatchFixes", "setIsGeneratedFlagForName", "void",
 						"org.eclipse.jdt.core.dom.Name", "java.lang.Object"))
 				.transplant().build());
 	}
@@ -493,7 +488,7 @@ public class EclipsePatcher implements AgentLauncher.AgentLaunchable {
 				.target(new MethodTarget(PARSER_SIG, "parse", "void",
 						"org.eclipse.jdt.internal.compiler.ast.MethodDeclaration",
 						"org.eclipse.jdt.internal.compiler.ast.CompilationUnitDeclaration"))
-				.decisionMethod(new Hook("lombok.eclipse.agent.PatchFixes", "checkBit24", "boolean", "java.lang.Object"))
+				.decisionMethod(new Hook("lombok.launch.PatchFixesHider$PatchFixes", "checkBit24", "boolean", "java.lang.Object"))
 				.transplant()
 				.request(StackRequest.PARAM1).build());
 		
@@ -501,7 +496,7 @@ public class EclipsePatcher implements AgentLauncher.AgentLaunchable {
 				.target(new MethodTarget(PARSER_SIG, "parse", "void",
 						"org.eclipse.jdt.internal.compiler.ast.ConstructorDeclaration",
 						"org.eclipse.jdt.internal.compiler.ast.CompilationUnitDeclaration", "boolean"))
-				.decisionMethod(new Hook("lombok.eclipse.agent.PatchFixes", "checkBit24", "boolean", "java.lang.Object"))
+				.decisionMethod(new Hook("lombok.launch.PatchFixesHider$PatchFixes", "checkBit24", "boolean", "java.lang.Object"))
 				.transplant()
 				.request(StackRequest.PARAM1).build());
 		
@@ -510,7 +505,7 @@ public class EclipsePatcher implements AgentLauncher.AgentLaunchable {
 						"org.eclipse.jdt.internal.compiler.ast.Initializer",
 						"org.eclipse.jdt.internal.compiler.ast.TypeDeclaration",
 						"org.eclipse.jdt.internal.compiler.ast.CompilationUnitDeclaration"))
-				.decisionMethod(new Hook("lombok.eclipse.agent.PatchFixes", "checkBit24", "boolean", "java.lang.Object"))
+				.decisionMethod(new Hook("lombok.launch.PatchFixesHider$PatchFixes", "checkBit24", "boolean", "java.lang.Object"))
 				.transplant()
 				.request(StackRequest.PARAM1).build());
 	}
@@ -526,12 +521,12 @@ public class EclipsePatcher implements AgentLauncher.AgentLaunchable {
 		
 		sm.addScript(ScriptBuilder.wrapReturnValue()
 				.target(new MethodTarget(PARSER_SIG, "getMethodBodies", "void", CUD_SIG))
-				.wrapMethod(new Hook("lombok.eclipse.TransformEclipseAST", "transform", "void", PARSER_SIG, CUD_SIG))
+				.wrapMethod(new Hook("lombok.launch.PatchFixesHider$Transform", "transform", "void", PARSER_SIG, CUD_SIG))
 				.request(StackRequest.THIS, StackRequest.PARAM1).build());
 		
 		sm.addScript(ScriptBuilder.wrapReturnValue()
 				.target(new MethodTarget(PARSER_SIG, "endParse", CUD_SIG, "int"))
-				.wrapMethod(new Hook("lombok.eclipse.TransformEclipseAST", "transform_swapped", "void", CUD_SIG, PARSER_SIG))
+				.wrapMethod(new Hook("lombok.launch.PatchFixesHider$Transform", "transform_swapped", "void", CUD_SIG, PARSER_SIG))
 				.request(StackRequest.THIS, StackRequest.RETURN_VALUE).build());
 	}
 	
@@ -547,7 +542,7 @@ public class EclipsePatcher implements AgentLauncher.AgentLaunchable {
 		sm.addScript(ScriptBuilder.exitEarly()
 				.target(new MethodTarget(CLASSSCOPE_SIG, "buildFieldsAndMethods", "void"))
 				.request(StackRequest.THIS)
-				.decisionMethod(new Hook("lombok.eclipse.agent.PatchDelegatePortal", "handleDelegateForType", "boolean", "java.lang.Object"))
+				.decisionMethod(new Hook("lombok.launch.PatchFixesHider$Delegate", "handleDelegateForType", "boolean", "java.lang.Object"))
 				.build());
 	}
 	
@@ -577,24 +572,24 @@ public class EclipsePatcher implements AgentLauncher.AgentLaunchable {
 		sm.addScript(ScriptBuilder.wrapReturnValue()
 				.target(new MethodTarget(PARSER_SIG, "consumeExitVariableWithInitialization", "void"))
 				.request(StackRequest.THIS)
-				.wrapMethod(new Hook("lombok.eclipse.agent.PatchValEclipsePortal", "copyInitializationOfLocalDeclaration", "void", "java.lang.Object"))
+				.wrapMethod(new Hook("lombok.launch.PatchFixesHider$ValPortal", "copyInitializationOfLocalDeclaration", "void", "java.lang.Object"))
 				.build());
 		
 		sm.addScript(ScriptBuilder.wrapReturnValue()
 				.target(new MethodTarget(PARSER_SIG, "consumeEnhancedForStatementHeader", "void"))
 				.request(StackRequest.THIS)
-				.wrapMethod(new Hook("lombok.eclipse.agent.PatchValEclipsePortal", "copyInitializationOfForEachIterable", "void", "java.lang.Object"))
+				.wrapMethod(new Hook("lombok.launch.PatchFixesHider$ValPortal", "copyInitializationOfForEachIterable", "void", "java.lang.Object"))
 				.build());
 		
 		sm.addScript(ScriptBuilder.wrapReturnValue()
 				.target(new MethodTarget(ASTCONVERTER_SIG, "setModifiers", "void", VARIABLEDECLARATIONSTATEMENT_SIG, LOCALDECLARATION_SIG))
-				.wrapMethod(new Hook("lombok.eclipse.agent.PatchValEclipsePortal", "addFinalAndValAnnotationToVariableDeclarationStatement",
+				.wrapMethod(new Hook("lombok.launch.PatchFixesHider$ValPortal", "addFinalAndValAnnotationToVariableDeclarationStatement",
 						"void", "java.lang.Object", "java.lang.Object", "java.lang.Object"))
 				.request(StackRequest.THIS, StackRequest.PARAM1, StackRequest.PARAM2).build());
 		
 		sm.addScript(ScriptBuilder.wrapReturnValue()
 				.target(new MethodTarget(ASTCONVERTER_SIG, "setModifiers", "void", SINGLEVARIABLEDECLARATION_SIG, LOCALDECLARATION_SIG))
-				.wrapMethod(new Hook("lombok.eclipse.agent.PatchValEclipsePortal", "addFinalAndValAnnotationToSingleVariableDeclaration",
+				.wrapMethod(new Hook("lombok.launch.PatchFixesHider$ValPortal", "addFinalAndValAnnotationToSingleVariableDeclaration",
 						"void", "java.lang.Object", "java.lang.Object", "java.lang.Object"))
 				.request(StackRequest.THIS, StackRequest.PARAM1, StackRequest.PARAM2).build());
 	}
@@ -609,26 +604,26 @@ public class EclipsePatcher implements AgentLauncher.AgentLaunchable {
 		sm.addScript(ScriptBuilder.exitEarly()
 				.target(new MethodTarget(LOCALDECLARATION_SIG, "resolve", "void", BLOCKSCOPE_SIG))
 				.request(StackRequest.THIS, StackRequest.PARAM1)
-				.decisionMethod(new Hook("lombok.eclipse.agent.PatchVal", "handleValForLocalDeclaration", "boolean", LOCALDECLARATION_SIG, BLOCKSCOPE_SIG))
+				.decisionMethod(new Hook("lombok.launch.PatchFixesHider$Val", "handleValForLocalDeclaration", "boolean", LOCALDECLARATION_SIG, BLOCKSCOPE_SIG))
 				.build());
 		
 		sm.addScript(ScriptBuilder.replaceMethodCall()
 				.target(new MethodTarget(LOCALDECLARATION_SIG, "resolve", "void", BLOCKSCOPE_SIG))
 				.methodToReplace(new Hook(EXPRESSION_SIG, "resolveType", TYPEBINDING_SIG, BLOCKSCOPE_SIG))
 				.requestExtra(StackRequest.THIS)
-				.replacementMethod(new Hook("lombok.eclipse.agent.PatchVal", "skipResolveInitializerIfAlreadyCalled2", TYPEBINDING_SIG, EXPRESSION_SIG, BLOCKSCOPE_SIG, LOCALDECLARATION_SIG))
+				.replacementMethod(new Hook("lombok.launch.PatchFixesHider$Val", "skipResolveInitializerIfAlreadyCalled2", TYPEBINDING_SIG, EXPRESSION_SIG, BLOCKSCOPE_SIG, LOCALDECLARATION_SIG))
 				.build());
 		
 		sm.addScript(ScriptBuilder.replaceMethodCall()
 				.target(new MethodTarget(FOREACHSTATEMENT_SIG, "resolve", "void", BLOCKSCOPE_SIG))
 				.methodToReplace(new Hook(EXPRESSION_SIG, "resolveType", TYPEBINDING_SIG, BLOCKSCOPE_SIG))
-				.replacementMethod(new Hook("lombok.eclipse.agent.PatchVal", "skipResolveInitializerIfAlreadyCalled", TYPEBINDING_SIG, EXPRESSION_SIG, BLOCKSCOPE_SIG))
+				.replacementMethod(new Hook("lombok.launch.PatchFixesHider$Val", "skipResolveInitializerIfAlreadyCalled", TYPEBINDING_SIG, EXPRESSION_SIG, BLOCKSCOPE_SIG))
 				.build());
 		
 		sm.addScript(ScriptBuilder.exitEarly()
 				.target(new MethodTarget(FOREACHSTATEMENT_SIG, "resolve", "void", BLOCKSCOPE_SIG))
 				.request(StackRequest.THIS, StackRequest.PARAM1)
-				.decisionMethod(new Hook("lombok.eclipse.agent.PatchVal", "handleValForForEach", "boolean", FOREACHSTATEMENT_SIG, BLOCKSCOPE_SIG))
+				.decisionMethod(new Hook("lombok.launch.PatchFixesHider$Val", "handleValForForEach", "boolean", FOREACHSTATEMENT_SIG, BLOCKSCOPE_SIG))
 				.build());
 	}
 	
@@ -639,7 +634,7 @@ public class EclipsePatcher implements AgentLauncher.AgentLaunchable {
 		
 		sm.addScript(ScriptBuilder.wrapReturnValue()
 				.target(new MethodTarget(SOURCE_TYPE_CONVERTER_SIG, "convertAnnotations", ANNOTATION_SIG + "[]", I_ANNOTATABLE_SIG))
-				.wrapMethod(new Hook("lombok.eclipse.agent.PatchFixes", "convertAnnotations", ANNOTATION_SIG + "[]", ANNOTATION_SIG + "[]", I_ANNOTATABLE_SIG))
+				.wrapMethod(new Hook("lombok.launch.PatchFixesHider$PatchFixes", "convertAnnotations", ANNOTATION_SIG + "[]", ANNOTATION_SIG + "[]", I_ANNOTATABLE_SIG))
 				.request(StackRequest.PARAM1, StackRequest.RETURN_VALUE).build());
 	}
 	
@@ -657,7 +652,7 @@ public class EclipsePatcher implements AgentLauncher.AgentLaunchable {
 	}
 	
 	private static void patchExtensionMethod(ScriptManager sm, boolean ecj) {
-		final String PATCH_EXTENSIONMETHOD = "lombok.eclipse.agent.PatchExtensionMethod";
+		final String PATCH_EXTENSIONMETHOD = "lombok.launch.PatchFixesHider$ExtensionMethod";
 		final String PATCH_EXTENSIONMETHOD_COMPLETIONPROPOSAL_PORTAL = "lombok.eclipse.agent.PatchExtensionMethodCompletionProposalPortal";
 		final String MESSAGE_SEND_SIG = "org.eclipse.jdt.internal.compiler.ast.MessageSend";
 		final String TYPE_BINDING_SIG = "org.eclipse.jdt.internal.compiler.lookup.TypeBinding";
diff --git a/src/eclipseAgent/lombok/eclipse/agent/PatchFixes.java b/src/eclipseAgent/lombok/eclipse/agent/PatchFixes.java
deleted file mode 100644
index d1c668a0..00000000
--- a/src/eclipseAgent/lombok/eclipse/agent/PatchFixes.java
+++ /dev/null
@@ -1,384 +0,0 @@
-/*
- * Copyright (C) 2010-2013 The Project Lombok Authors.
- * 
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- * 
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
- * THE SOFTWARE.
- */
-package lombok.eclipse.agent;
-
-import java.io.BufferedOutputStream;
-import java.io.IOException;
-import java.io.OutputStream;
-import java.lang.reflect.Field;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Stack;
-
-import lombok.core.DiagnosticsReceiver;
-import lombok.core.PostCompiler;
-import lombok.core.Version;
-import lombok.eclipse.EclipseAugments;
-
-import org.eclipse.core.runtime.CoreException;
-import org.eclipse.jdt.core.IAnnotatable;
-import org.eclipse.jdt.core.IAnnotation;
-import org.eclipse.jdt.core.IMethod;
-import org.eclipse.jdt.core.IType;
-import org.eclipse.jdt.core.JavaModelException;
-import org.eclipse.jdt.core.dom.MethodDeclaration;
-import org.eclipse.jdt.core.dom.SimpleName;
-import org.eclipse.jdt.internal.compiler.ast.Annotation;
-import org.eclipse.jdt.internal.core.dom.rewrite.NodeRewriteEvent;
-import org.eclipse.jdt.internal.core.dom.rewrite.RewriteEvent;
-import org.eclipse.jdt.internal.core.dom.rewrite.TokenScanner;
-import org.eclipse.jdt.internal.corext.refactoring.structure.ASTNodeSearchUtil;
-
-public class PatchFixes {
-	public static String addLombokNotesToEclipseAboutDialog(String origReturnValue, String key) {
-		if ("aboutText".equals(key)) {
-			return origReturnValue + "\n\nLombok " + Version.getFullVersion() + " is installed. http://projectlombok.org/";
-		}
-		
-		return origReturnValue;
-	}
-	
-	public static boolean isGenerated(org.eclipse.jdt.core.dom.ASTNode node) {
-		boolean result = false;
-		try {
-			result =  ((Boolean)node.getClass().getField("$isGenerated").get(node)).booleanValue();
-			if (!result && node.getParent() != null && node.getParent() instanceof org.eclipse.jdt.core.dom.QualifiedName)
-				result = isGenerated(node.getParent());
-		} catch (Exception e) {
-			// better to assume it isn't generated
-		}
-		return result;
-	}
-	
-	public static boolean isListRewriteOnGeneratedNode(org.eclipse.jdt.core.dom.rewrite.ListRewrite rewrite) {
-		return isGenerated(rewrite.getParent());
-	}
-	
-	public static boolean returnFalse(java.lang.Object object) {
-		return false;
-	}
-	
-	public static boolean returnTrue(java.lang.Object object) {
-		return true;
-	}
-	
-	@java.lang.SuppressWarnings({"unchecked", "rawtypes"}) public static java.util.List removeGeneratedNodes(java.util.List list) {
-		try {
-			java.util.List realNodes = new java.util.ArrayList(list.size());
-			for (java.lang.Object node : list) {
-				if(!isGenerated(((org.eclipse.jdt.core.dom.ASTNode)node))) {
-					realNodes.add(node);
-				}
-			}
-			return realNodes;
-		} catch (Exception e) {
-		}
-		return list;
-	}
-	
-	public static java.lang.String getRealMethodDeclarationSource(java.lang.String original, Object processor, org.eclipse.jdt.core.dom.MethodDeclaration declaration) throws Exception {
-		if (!isGenerated(declaration)) return original;
-		
-		List<org.eclipse.jdt.core.dom.Annotation> annotations = new ArrayList<org.eclipse.jdt.core.dom.Annotation>();
-		for (Object modifier : declaration.modifiers()) {
-			if (modifier instanceof org.eclipse.jdt.core.dom.Annotation) {
-				org.eclipse.jdt.core.dom.Annotation annotation = (org.eclipse.jdt.core.dom.Annotation)modifier;
-				String qualifiedAnnotationName = annotation.resolveTypeBinding().getQualifiedName();
-				if (!"java.lang.Override".equals(qualifiedAnnotationName) && !"java.lang.SuppressWarnings".equals(qualifiedAnnotationName)) annotations.add(annotation);
-			}
-		}
-		
-		StringBuilder signature = new StringBuilder();
-		addAnnotations(annotations, signature);
-		
-		if ((Boolean)processor.getClass().getDeclaredField("fPublic").get(processor)) signature.append("public ");
-		if ((Boolean)processor.getClass().getDeclaredField("fAbstract").get(processor)) signature.append("abstract ");
-		
-		signature
-			.append(declaration.getReturnType2().toString())
-			.append(" ").append(declaration.getName().getFullyQualifiedName())
-			.append("(");
-		
-		boolean first = true;
-		for (Object parameter : declaration.parameters()) {
-			if (!first) signature.append(", ");
-			first = false;
-			// We should also add the annotations of the parameters
-			signature.append(parameter);
-		}
-		
-		signature.append(");");
-		return signature.toString();
-	}
-	
-	// part of getRealMethodDeclarationSource(...)
-	public static void addAnnotations(List<org.eclipse.jdt.core.dom.Annotation> annotations, StringBuilder signature) {
-		/*
-		 * We SHOULD be able to handle the following cases:
-		 * @Override
-		 * @Override()
-		 * @SuppressWarnings("all")
-		 * @SuppressWarnings({"all", "unused"})
-		 * @SuppressWarnings(value = "all")
-		 * @SuppressWarnings(value = {"all", "unused"})
-		 * @EqualsAndHashCode(callSuper=true, of="id")
-		 * 
-		 * Currently, we only seem to correctly support:
-		 * @Override
-		 * @Override() N.B. We lose the parentheses here, since there are no values. No big deal.
-		 * @SuppressWarnings("all")
-		 */
-		for (org.eclipse.jdt.core.dom.Annotation annotation : annotations) {
-			List<String> values = new ArrayList<String>();
-			if (annotation.isSingleMemberAnnotation()) {
-				org.eclipse.jdt.core.dom.SingleMemberAnnotation smAnn = (org.eclipse.jdt.core.dom.SingleMemberAnnotation) annotation;
-				values.add(smAnn.getValue().toString());
-			} else if (annotation.isNormalAnnotation()) {
-				org.eclipse.jdt.core.dom.NormalAnnotation normalAnn = (org.eclipse.jdt.core.dom.NormalAnnotation) annotation;
-				for (Object value : normalAnn.values()) values.add(value.toString());
-			}
-			
-			signature.append("@").append(annotation.resolveTypeBinding().getQualifiedName());
-			if (!values.isEmpty()) {
-				signature.append("(");
-				boolean first = true;
-				for (String string : values) {
-					if (!first) signature.append(", ");
-					first = false;
-					signature.append('"').append(string).append('"');
-				}
-				signature.append(")");
-			}
-			signature.append(" ");
-		}
-	}
-	
-	public static org.eclipse.jdt.core.dom.MethodDeclaration getRealMethodDeclarationNode(org.eclipse.jdt.core.IMethod sourceMethod, org.eclipse.jdt.core.dom.CompilationUnit cuUnit) throws JavaModelException {
-		MethodDeclaration methodDeclarationNode = ASTNodeSearchUtil.getMethodDeclarationNode(sourceMethod, cuUnit);
-		if (isGenerated(methodDeclarationNode)) {
-			IType declaringType = sourceMethod.getDeclaringType();
-			Stack<IType> typeStack = new Stack<IType>();
-			while (declaringType != null) {
-				typeStack.push(declaringType);
-				declaringType = declaringType.getDeclaringType();
-			}
-			
-			IType rootType = typeStack.pop();
-			org.eclipse.jdt.core.dom.AbstractTypeDeclaration typeDeclaration = findTypeDeclaration(rootType, cuUnit.types());
-			while (!typeStack.isEmpty() && typeDeclaration != null) {
-				typeDeclaration = findTypeDeclaration(typeStack.pop(), typeDeclaration.bodyDeclarations());
-			}
-
-			if (typeStack.isEmpty() && typeDeclaration != null) {
-				String methodName = sourceMethod.getElementName();
-				for (Object declaration : typeDeclaration.bodyDeclarations()) {
-					if (declaration instanceof org.eclipse.jdt.core.dom.MethodDeclaration) {
-						org.eclipse.jdt.core.dom.MethodDeclaration methodDeclaration = (org.eclipse.jdt.core.dom.MethodDeclaration) declaration;
-						if (methodDeclaration.getName().toString().equals(methodName)) {
-							return methodDeclaration;
-						}
-					}
-				}
-			}
-		}
-		return methodDeclarationNode;
-	}
-	
-	// part of getRealMethodDeclarationNode
-	public static org.eclipse.jdt.core.dom.AbstractTypeDeclaration findTypeDeclaration(IType searchType, List<?> nodes) {
-		for (Object object : nodes) {
-			if (object instanceof org.eclipse.jdt.core.dom.AbstractTypeDeclaration) {
-				org.eclipse.jdt.core.dom.AbstractTypeDeclaration typeDeclaration = (org.eclipse.jdt.core.dom.AbstractTypeDeclaration) object;
-				if (typeDeclaration.getName().toString().equals(searchType.getElementName()))
-					return typeDeclaration;
-			}
-		}
-		return null;
-	}
-	
-	public static int getSourceEndFixed(int sourceEnd, org.eclipse.jdt.internal.compiler.ast.ASTNode node) throws Exception {
-		if (sourceEnd == -1) {
-			org.eclipse.jdt.internal.compiler.ast.ASTNode object = (org.eclipse.jdt.internal.compiler.ast.ASTNode)node.getClass().getField("$generatedBy").get(node);
-			if (object != null) {
-				return object.sourceEnd;
-			}
-		}
-		return sourceEnd;
-	}
-	
-	public static int fixRetrieveStartingCatchPosition(int original, int start) {
-		return original == -1 ? start : original;
-	}
-	
-	public static int fixRetrieveIdentifierEndPosition(int original, int end) {
-		return original == -1 ? end : original;
-	}
-	
-	public static int fixRetrieveEllipsisStartPosition(int original, int end) {
-		return original == -1 ? end : original;
-	}
-	
-	public static int fixRetrieveRightBraceOrSemiColonPosition(int original, int end) {
-//		return original;
-		 return original == -1 ? end : original;  // Need to fix: see issue 325.
-	}
-	
-	public static final int ALREADY_PROCESSED_FLAG = 0x800000;  //Bit 24
-	
-	public static boolean checkBit24(Object node) throws Exception {
-		int bits = (Integer)(node.getClass().getField("bits").get(node));
-		return (bits & ALREADY_PROCESSED_FLAG) != 0;
-	}
-	
-	public static boolean skipRewritingGeneratedNodes(org.eclipse.jdt.core.dom.ASTNode node) throws Exception {
-		return ((Boolean)node.getClass().getField("$isGenerated").get(node)).booleanValue();
-	}
-	
-	public static void setIsGeneratedFlag(org.eclipse.jdt.core.dom.ASTNode domNode,
-			org.eclipse.jdt.internal.compiler.ast.ASTNode internalNode) throws Exception {
-		if (internalNode == null || domNode == null) return;
-		boolean isGenerated = EclipseAugments.ASTNode_generatedBy.get(internalNode) != null;
-		if (isGenerated) domNode.getClass().getField("$isGenerated").set(domNode, true);
-	}
-	
-	public static void setIsGeneratedFlagForName(org.eclipse.jdt.core.dom.Name name, Object internalNode) throws Exception {
-		if (internalNode instanceof org.eclipse.jdt.internal.compiler.ast.ASTNode) {
-			if (EclipseAugments.ASTNode_generatedBy.get((org.eclipse.jdt.internal.compiler.ast.ASTNode) internalNode) != null) {
-				name.getClass().getField("$isGenerated").set(name, true);
-			}
-		}
-	}
-	
-	public static RewriteEvent[] listRewriteHandleGeneratedMethods(RewriteEvent parent) {
-		RewriteEvent[] children = parent.getChildren();
-		List<RewriteEvent> newChildren = new ArrayList<RewriteEvent>();
-		List<RewriteEvent> modifiedChildren = new ArrayList<RewriteEvent>();
-		for (int i=0; i<children.length; i++) {
-			RewriteEvent child = children[i];
-			boolean isGenerated = isGenerated( (org.eclipse.jdt.core.dom.ASTNode)child.getOriginalValue() );
-			if (isGenerated) {
-				if ((child.getChangeKind() == RewriteEvent.REPLACED || child.getChangeKind() == RewriteEvent.REMOVED) 
-					&& child.getOriginalValue() instanceof org.eclipse.jdt.core.dom.MethodDeclaration
-					&& child.getNewValue() != null
-				) {
-					modifiedChildren.add(new NodeRewriteEvent(null, child.getNewValue()));
-				}
-			} else {
-				newChildren.add(child);
-			}
-		}
-		// Since Eclipse doesn't honor the "insert at specified location" for already existing members,
-		// we'll just add them last
-		newChildren.addAll(modifiedChildren);
-		return newChildren.toArray(new RewriteEvent[newChildren.size()]);
-	}
-
-	public static int getTokenEndOffsetFixed(TokenScanner scanner, int token, int startOffset, Object domNode) throws CoreException {
-		boolean isGenerated = false;
-		try {
-			isGenerated = (Boolean) domNode.getClass().getField("$isGenerated").get(domNode);
-		} catch (Exception e) {
-			// If this fails, better to break some refactor scripts than to crash eclipse.
-		}
-		if (isGenerated) return -1;
-		return scanner.getTokenEndOffset(token, startOffset);
-	}
-	
-	public static IMethod[] removeGeneratedMethods(IMethod[] methods) throws Exception {
-		List<IMethod> result = new ArrayList<IMethod>();
-		for (IMethod m : methods) {
-			if (m.getNameRange().getLength() > 0 && !m.getNameRange().equals(m.getSourceRange())) result.add(m);
-		}
-		return result.size() == methods.length ? methods : result.toArray(new IMethod[result.size()]);
-	}
-	
-	public static SimpleName[] removeGeneratedSimpleNames(SimpleName[] in) throws Exception {
-		Field f = SimpleName.class.getField("$isGenerated");
-		
-		int count = 0;
-		for (int i = 0; i < in.length; i++) {
-			if (in[i] == null || !((Boolean)f.get(in[i])).booleanValue()) count++;
-		}
-		if (count == in.length) return in;
-		SimpleName[] newSimpleNames = new SimpleName[count];
-		count = 0;
-		for (int i = 0; i < in.length; i++) {
-			if (in[i] == null || !((Boolean)f.get(in[i])).booleanValue()) newSimpleNames[count++] = in[i];
-		}
-		return newSimpleNames;
-	}
-	
-	public static byte[] runPostCompiler(byte[] bytes, String fileName) {
-		byte[] transformed = PostCompiler.applyTransformations(bytes, fileName, DiagnosticsReceiver.CONSOLE);
-		return transformed == null ? bytes : transformed;
-	}
-	
-	public static OutputStream runPostCompiler(OutputStream out) throws IOException {
-		return PostCompiler.wrapOutputStream(out, "TEST", DiagnosticsReceiver.CONSOLE);
-	}
-	
-	public static BufferedOutputStream runPostCompiler(BufferedOutputStream out, String path, String name) throws IOException {
-		String fileName = path + "/" + name;
-		return new BufferedOutputStream(PostCompiler.wrapOutputStream(out, fileName, DiagnosticsReceiver.CONSOLE));
-	}
-	
-	public static Annotation[] convertAnnotations(Annotation[] out, IAnnotatable annotatable) {
-		IAnnotation[] in;
-		
-		try {
-			in = annotatable.getAnnotations();
-		} catch (Exception e) {
-			return out;
-		}
-		
-		if (out == null) return null;
-		int toWrite = 0;
-		
-		for (int idx = 0; idx < out.length; idx++) {
-			String oName = new String(out[idx].type.getLastToken());
-			boolean found = false;
-			for (IAnnotation i : in) {
-				String name = i.getElementName();
-				int li = name.lastIndexOf('.');
-				if (li > -1) name = name.substring(li + 1);
-				if (name.equals(oName)) {
-					found = true;
-					break;
-				}
-			}
-			if (!found) out[idx] = null;
-			else toWrite++;
-		}
-		
-		Annotation[] replace = out;
-		if (toWrite < out.length) {
-			replace = new Annotation[toWrite];
-			int idx = 0;
-			for (int i = 0; i < out.length; i++) {
-				if (out[i] == null) continue;
-				replace[idx++] = out[i];
-			}
-		}
-		
-		return replace;
-	}
-}
diff --git a/src/eclipseAgent/lombok/eclipse/agent/PatchFixesShadowLoaded.java b/src/eclipseAgent/lombok/eclipse/agent/PatchFixesShadowLoaded.java
new file mode 100644
index 00000000..6685b6bb
--- /dev/null
+++ b/src/eclipseAgent/lombok/eclipse/agent/PatchFixesShadowLoaded.java
@@ -0,0 +1,53 @@
+/*
+ * Copyright (C) 2015 The Project Lombok Authors.
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+package lombok.eclipse.agent;
+
+import java.io.BufferedOutputStream;
+import java.io.IOException;
+import java.io.OutputStream;
+
+import lombok.core.DiagnosticsReceiver;
+import lombok.core.PostCompiler;
+import lombok.core.Version;
+
+public class PatchFixesShadowLoaded {
+	public static String addLombokNotesToEclipseAboutDialog(String origReturnValue, String key) {
+		if ("aboutText".equals(key)) {
+			return origReturnValue + "\n\nLombok " + Version.getFullVersion() + " is installed. http://projectlombok.org/";
+		}
+		return origReturnValue;
+	}
+	
+	public static byte[] runPostCompiler(byte[] bytes, String fileName) {
+		byte[] transformed = PostCompiler.applyTransformations(bytes, fileName, DiagnosticsReceiver.CONSOLE);
+		return transformed == null ? bytes : transformed;
+	}
+	
+	public static OutputStream runPostCompiler(OutputStream out) throws IOException {
+		return PostCompiler.wrapOutputStream(out, "TEST", DiagnosticsReceiver.CONSOLE);
+	}
+	
+	public static BufferedOutputStream runPostCompiler(BufferedOutputStream out, String path, String name) throws IOException {
+		String fileName = path + "/" + name;
+		return new BufferedOutputStream(PostCompiler.wrapOutputStream(out, fileName, DiagnosticsReceiver.CONSOLE));
+	}
+}
diff --git a/src/eclipseAgent/lombok/launch/PatchFixesHider.java b/src/eclipseAgent/lombok/launch/PatchFixesHider.java
new file mode 100644
index 00000000..23774d0f
--- /dev/null
+++ b/src/eclipseAgent/lombok/launch/PatchFixesHider.java
@@ -0,0 +1,587 @@
+/*
+ * Copyright (C) 2010-2015 The Project Lombok Authors.
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+package lombok.launch;
+
+import java.io.BufferedOutputStream;
+import java.io.IOException;
+import java.io.OutputStream;
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Stack;
+
+import lombok.eclipse.EclipseAugments;
+
+import org.eclipse.core.runtime.CoreException;
+import org.eclipse.jdt.core.IAnnotatable;
+import org.eclipse.jdt.core.IAnnotation;
+import org.eclipse.jdt.core.IMethod;
+import org.eclipse.jdt.core.IType;
+import org.eclipse.jdt.core.JavaModelException;
+import org.eclipse.jdt.core.dom.MethodDeclaration;
+import org.eclipse.jdt.core.dom.SimpleName;
+import org.eclipse.jdt.internal.compiler.ast.Annotation;
+import org.eclipse.jdt.internal.compiler.ast.CompilationUnitDeclaration;
+import org.eclipse.jdt.internal.compiler.ast.Expression;
+import org.eclipse.jdt.internal.compiler.ast.ForeachStatement;
+import org.eclipse.jdt.internal.compiler.ast.LocalDeclaration;
+import org.eclipse.jdt.internal.compiler.ast.MessageSend;
+import org.eclipse.jdt.internal.compiler.lookup.BlockScope;
+import org.eclipse.jdt.internal.compiler.lookup.MethodBinding;
+import org.eclipse.jdt.internal.compiler.lookup.TypeBinding;
+import org.eclipse.jdt.internal.compiler.parser.Parser;
+import org.eclipse.jdt.internal.compiler.problem.ProblemReporter;
+import org.eclipse.jdt.internal.core.dom.rewrite.NodeRewriteEvent;
+import org.eclipse.jdt.internal.core.dom.rewrite.RewriteEvent;
+import org.eclipse.jdt.internal.core.dom.rewrite.TokenScanner;
+import org.eclipse.jdt.internal.corext.refactoring.structure.ASTNodeSearchUtil;
+
+/** These contain a mix of the following:
+ * <ul>
+ * <li> 'dependency free' method wrappers that cross the shadowloader barrier.
+ * <li> methods that directly patch, <em>but</em>, these should ALWAYS be transplanted.
+ * </ul>
+ * 
+ * <strong>This class lives on the outside of the shadowloader barrier, and as a consequence, cannot access any other lombok code except other
+ * code in the {@code lombok.launch} package!</strong>.
+ * <p>
+ * This class is package private with lots of public inner static classes. This hides all of them from IDE autocomplete dialogs and such but at the JVM
+ * level the inner static class are just plain public, which is important, because calls to the contents of these inner static classes are injected into
+ * various eclipse classes verbatim, and if they weren't public, the verifier wouldn't accept it.
+ */
+final class PatchFixesHider {
+	
+	/** These utility methods are only used 'internally', but because of transplant methods, the class (and its methods) still have to be public! */
+	public static final class Util {
+		public static Class<?> shadowLoadClass(String name) {
+			try {
+				return Class.forName(name, true, Main.createShadowClassLoader());
+			} catch (ClassNotFoundException e) {
+				throw sneakyThrow(e);
+			}
+		}
+		
+		public static Method findMethod(Class<?> type, String name, Class<?>... parameterTypes) {
+			try {
+				return type.getDeclaredMethod(name, parameterTypes);
+			} catch (NoSuchMethodException e) {
+				throw sneakyThrow(e);
+			}
+		}
+		
+		public static Object invokeMethod(Method method, Object... args) {
+			try {
+				return method.invoke(null, args);
+			} catch (IllegalAccessException e) {
+				throw sneakyThrow(e);
+			} catch (InvocationTargetException e) {
+				throw sneakyThrow(e.getCause());
+			}
+		}
+		
+		private static RuntimeException sneakyThrow(Throwable t) {
+			if (t == null) throw new NullPointerException("t");
+			Util.<RuntimeException>sneakyThrow0(t);
+			return null;
+		}
+		
+		@SuppressWarnings("unchecked")
+		private static <T extends Throwable> void sneakyThrow0(Throwable t) throws T {
+			throw (T)t;
+		}
+	}
+	
+	/** Contains patch fixes that are dependent on lombok internals. */
+	public static final class LombokDeps {
+		public static final Method ADD_LOMBOK_NOTES;
+		public static final Method POST_COMPILER_BYTES_STRING;
+		public static final Method POST_COMPILER_OUTPUTSTREAM;
+		public static final Method POST_COMPILER_BUFFEREDOUTPUTSTREAM_STRING_STRING;
+		
+		static {
+			Class<?> shadowed = Util.shadowLoadClass("lombok.eclipse.agent.PatchFixesShadowLoaded");
+			ADD_LOMBOK_NOTES = Util.findMethod(shadowed, "addLombokNotesToEclipseAboutDialog", String.class, String.class);
+			POST_COMPILER_BYTES_STRING = Util.findMethod(shadowed, "runPostCompiler", byte[].class, String.class);
+			POST_COMPILER_OUTPUTSTREAM = Util.findMethod(shadowed, "runPostCompiler", OutputStream.class);
+			POST_COMPILER_BUFFEREDOUTPUTSTREAM_STRING_STRING = Util.findMethod(shadowed, "runPostCompiler", BufferedOutputStream.class, String.class, String.class);
+		}
+		
+		public static String addLombokNotesToEclipseAboutDialog(String origReturnValue, String key) {
+			return (String) Util.invokeMethod(LombokDeps.ADD_LOMBOK_NOTES, origReturnValue, key);
+		}
+		
+		public static byte[] runPostCompiler(byte[] bytes, String fileName) {
+			return (byte[]) Util.invokeMethod(LombokDeps.POST_COMPILER_BYTES_STRING, bytes, fileName);
+		}
+		
+		public static OutputStream runPostCompiler(OutputStream out) throws IOException {
+			return (OutputStream) Util.invokeMethod(LombokDeps.POST_COMPILER_OUTPUTSTREAM, out);
+		}
+		
+		public static BufferedOutputStream runPostCompiler(BufferedOutputStream out, String path, String name) throws IOException {
+			return (BufferedOutputStream) Util.invokeMethod(LombokDeps.POST_COMPILER_BUFFEREDOUTPUTSTREAM_STRING_STRING, out, path, name);
+		}
+	}
+	
+	public static final class Transform {
+		private static final Method TRANSFORM;
+		private static final Method TRANSFORM_SWAPPED;
+		
+		static {
+			Class<?> shadowed = Util.shadowLoadClass("lombok.eclipse.TransformEclipseAST");
+			TRANSFORM = Util.findMethod(shadowed, "transform", Parser.class, CompilationUnitDeclaration.class);
+			TRANSFORM_SWAPPED = Util.findMethod(shadowed, "transform_swapped", CompilationUnitDeclaration.class, Parser.class);
+		}
+		
+		public static void transform(Parser parser, CompilationUnitDeclaration ast) throws IOException {
+			Util.invokeMethod(TRANSFORM, parser, ast);
+		}
+		
+		public static void transform_swapped(CompilationUnitDeclaration ast, Parser parser) throws IOException {
+			Util.invokeMethod(TRANSFORM_SWAPPED, ast, parser);
+		}
+	}
+	
+	/** Contains patch code to support {@code @Delegate} */
+	public static final class Delegate {
+		private static final Method HANDLE_DELEGATE_FOR_TYPE;
+		
+		static {
+			Class<?> shadowed = Util.shadowLoadClass("lombok.eclipse.agent.PatchDelegatePortal");
+			HANDLE_DELEGATE_FOR_TYPE = Util.findMethod(shadowed, "handleDelegateForType", Object.class);
+		}
+		
+		public static boolean handleDelegateForType(Object classScope) {
+			return (Boolean) Util.invokeMethod(HANDLE_DELEGATE_FOR_TYPE, classScope);
+		}
+	}
+	
+	/** Contains patch code to support {@code val} (eclipse specific) */
+	public static final class ValPortal {
+		private static final Method COPY_INITIALIZATION_OF_FOR_EACH_ITERABLE;
+		private static final Method COPY_INITIALIZATION_OF_LOCAL_DECLARATION;
+		private static final Method ADD_FINAL_AND_VAL_ANNOTATION_TO_VARIABLE_DECLARATION_STATEMENT;
+		private static final Method ADD_FINAL_AND_VAL_ANNOTATION_TO_SINGLE_VARIABLE_DECLARATION;
+		
+		static {
+			Class<?> shadowed = Util.shadowLoadClass("lombok.eclipse.agent.PatchValEclipsePortal");
+			COPY_INITIALIZATION_OF_FOR_EACH_ITERABLE = Util.findMethod(shadowed, "copyInitializationOfForEachIterable", Object.class);
+			COPY_INITIALIZATION_OF_LOCAL_DECLARATION = Util.findMethod(shadowed, "copyInitializationOfLocalDeclaration", Object.class);
+			ADD_FINAL_AND_VAL_ANNOTATION_TO_VARIABLE_DECLARATION_STATEMENT = Util.findMethod(shadowed, "addFinalAndValAnnotationToVariableDeclarationStatement", Object.class, Object.class, Object.class);
+			ADD_FINAL_AND_VAL_ANNOTATION_TO_SINGLE_VARIABLE_DECLARATION = Util.findMethod(shadowed, "addFinalAndValAnnotationToSingleVariableDeclaration", Object.class, Object.class, Object.class);
+		}
+
+		public static void copyInitializationOfForEachIterable(Object parser) {
+			Util.invokeMethod(COPY_INITIALIZATION_OF_FOR_EACH_ITERABLE, parser);
+		}
+		
+		public static void copyInitializationOfLocalDeclaration(Object parser) {
+			Util.invokeMethod(COPY_INITIALIZATION_OF_LOCAL_DECLARATION, parser);
+		}
+		
+		public static void addFinalAndValAnnotationToVariableDeclarationStatement(Object converter, Object out, Object in) {
+			Util.invokeMethod(ADD_FINAL_AND_VAL_ANNOTATION_TO_VARIABLE_DECLARATION_STATEMENT, converter, out, in);
+		}
+		
+		public static void addFinalAndValAnnotationToSingleVariableDeclaration(Object converter, Object out, Object in) {
+			Util.invokeMethod(ADD_FINAL_AND_VAL_ANNOTATION_TO_SINGLE_VARIABLE_DECLARATION, converter, out, in);
+		}
+	}
+	
+	/** Contains patch code to support {@code val} (eclipse and ecj) */
+	public static final class Val {
+		private static final Method SKIP_RESOLVE_INITIALIZER_IF_ALREADY_CALLED;
+		private static final Method SKIP_RESOLVE_INITIALIZER_IF_ALREADY_CALLED2;
+		private static final Method HANDLE_VAL_FOR_LOCAL_DECLARATION;
+		private static final Method HANDLE_VAL_FOR_FOR_EACH;
+		
+		static {
+			Class<?> shadowed = Util.shadowLoadClass("lombok.eclipse.agent.PatchVal");
+			SKIP_RESOLVE_INITIALIZER_IF_ALREADY_CALLED = Util.findMethod(shadowed, "skipResolveInitializerIfAlreadyCalled", Expression.class, BlockScope.class);
+			SKIP_RESOLVE_INITIALIZER_IF_ALREADY_CALLED2 = Util.findMethod(shadowed, "skipResolveInitializerIfAlreadyCalled2", Expression.class, BlockScope.class, LocalDeclaration.class);
+			HANDLE_VAL_FOR_LOCAL_DECLARATION = Util.findMethod(shadowed, "handleValForLocalDeclaration", LocalDeclaration.class, BlockScope.class);
+			HANDLE_VAL_FOR_FOR_EACH = Util.findMethod(shadowed, "handleValForForEach", ForeachStatement.class, BlockScope.class);
+		}
+		
+		public static TypeBinding skipResolveInitializerIfAlreadyCalled(Expression expr, BlockScope scope) {
+			return (TypeBinding) Util.invokeMethod(SKIP_RESOLVE_INITIALIZER_IF_ALREADY_CALLED, expr, scope);
+		}
+		
+		public static TypeBinding skipResolveInitializerIfAlreadyCalled2(Expression expr, BlockScope scope, LocalDeclaration decl) {
+			return (TypeBinding) Util.invokeMethod(SKIP_RESOLVE_INITIALIZER_IF_ALREADY_CALLED2, expr, scope, decl);
+		}
+		
+		public static boolean handleValForLocalDeclaration(LocalDeclaration local, BlockScope scope) {
+			return (Boolean) Util.invokeMethod(HANDLE_VAL_FOR_LOCAL_DECLARATION, local, scope);
+		}
+		
+		public static boolean handleValForForEach(ForeachStatement forEach, BlockScope scope) {
+			return (Boolean) Util.invokeMethod(HANDLE_VAL_FOR_FOR_EACH, forEach, scope);
+		}
+	}
+	
+	/** Contains patch code to support {@code @ExtensionMethod} */
+	public static final class ExtensionMethod {
+		private static final Method RESOLVE_TYPE;
+		private static final Method ERROR_NO_METHOD_FOR;
+		private static final Method INVALID_METHOD;
+		
+		static {
+			Class<?> shadowed = Util.shadowLoadClass("lombok.eclipse.agent.PatchExtensionMethod");
+			RESOLVE_TYPE = Util.findMethod(shadowed, "resolveType", TypeBinding.class, MessageSend.class, BlockScope.class);
+			ERROR_NO_METHOD_FOR = Util.findMethod(shadowed, "errorNoMethodFor", ProblemReporter.class, MessageSend.class, TypeBinding.class, TypeBinding[].class);
+			INVALID_METHOD = Util.findMethod(shadowed, "invalidMethod", ProblemReporter.class, MessageSend.class, MethodBinding.class);
+		}
+		
+		public static TypeBinding resolveType(TypeBinding resolvedType, MessageSend methodCall, BlockScope scope) {
+			return (TypeBinding) Util.invokeMethod(RESOLVE_TYPE, resolvedType, methodCall, scope);
+		}
+		
+		public static void errorNoMethodFor(ProblemReporter problemReporter, MessageSend messageSend, TypeBinding recType, TypeBinding[] params) {
+			Util.invokeMethod(ERROR_NO_METHOD_FOR, problemReporter, messageSend, recType, params);
+		}
+		
+		public static void invalidMethod(ProblemReporter problemReporter, MessageSend messageSend, MethodBinding method) {
+			Util.invokeMethod(INVALID_METHOD, problemReporter, messageSend, method);
+		}
+	}
+	
+	/**
+	 * Contains a mix of methods: ecj only, ecj+eclipse, and eclipse only. As a consequence, _EVERY_ method from here used for ecj MUST be
+	 * transplanted, as ecj itself cannot load this class (signatures refer to things that don't exist in ecj-only mode).
+	 * <p>
+	 * Because of usage of transplant(), a bunch of these contain direct code and don't try to cross the shadowloader barrier.
+	 */
+	public static final class PatchFixes {
+		public static boolean isGenerated(org.eclipse.jdt.core.dom.ASTNode node) {
+			boolean result = false;
+			try {
+				result = ((Boolean)node.getClass().getField("$isGenerated").get(node)).booleanValue();
+				if (!result && node.getParent() != null && node.getParent() instanceof org.eclipse.jdt.core.dom.QualifiedName) {
+					result = isGenerated(node.getParent());
+				}
+			} catch (Exception e) {
+				// better to assume it isn't generated
+			}
+			return result;
+		}
+		
+		public static boolean isListRewriteOnGeneratedNode(org.eclipse.jdt.core.dom.rewrite.ListRewrite rewrite) {
+			return isGenerated(rewrite.getParent());
+		}
+		
+		public static boolean returnFalse(java.lang.Object object) {
+			return false;
+		}
+		
+		public static boolean returnTrue(java.lang.Object object) {
+			return true;
+		}
+		
+		@java.lang.SuppressWarnings({"unchecked", "rawtypes"}) public static java.util.List removeGeneratedNodes(java.util.List list) {
+			try {
+				java.util.List realNodes = new java.util.ArrayList(list.size());
+				for (java.lang.Object node : list) {
+					if(!isGenerated(((org.eclipse.jdt.core.dom.ASTNode)node))) {
+						realNodes.add(node);
+					}
+				}
+				return realNodes;
+			} catch (Exception e) {
+			}
+			return list;
+		}
+		
+		public static java.lang.String getRealMethodDeclarationSource(java.lang.String original, Object processor, org.eclipse.jdt.core.dom.MethodDeclaration declaration) throws Exception {
+			if (!isGenerated(declaration)) return original;
+			
+			List<org.eclipse.jdt.core.dom.Annotation> annotations = new ArrayList<org.eclipse.jdt.core.dom.Annotation>();
+			for (Object modifier : declaration.modifiers()) {
+				if (modifier instanceof org.eclipse.jdt.core.dom.Annotation) {
+					org.eclipse.jdt.core.dom.Annotation annotation = (org.eclipse.jdt.core.dom.Annotation)modifier;
+					String qualifiedAnnotationName = annotation.resolveTypeBinding().getQualifiedName();
+					if (!"java.lang.Override".equals(qualifiedAnnotationName) && !"java.lang.SuppressWarnings".equals(qualifiedAnnotationName)) annotations.add(annotation);
+				}
+			}
+			
+			StringBuilder signature = new StringBuilder();
+			addAnnotations(annotations, signature);
+			
+			if ((Boolean)processor.getClass().getDeclaredField("fPublic").get(processor)) signature.append("public ");
+			if ((Boolean)processor.getClass().getDeclaredField("fAbstract").get(processor)) signature.append("abstract ");
+			
+			signature
+				.append(declaration.getReturnType2().toString())
+				.append(" ").append(declaration.getName().getFullyQualifiedName())
+				.append("(");
+			
+			boolean first = true;
+			for (Object parameter : declaration.parameters()) {
+				if (!first) signature.append(", ");
+				first = false;
+				// We should also add the annotations of the parameters
+				signature.append(parameter);
+			}
+			
+			signature.append(");");
+			return signature.toString();
+		}
+		
+		// part of getRealMethodDeclarationSource(...)
+		public static void addAnnotations(List<org.eclipse.jdt.core.dom.Annotation> annotations, StringBuilder signature) {
+			/*
+			 * We SHOULD be able to handle the following cases:
+			 * @Override
+			 * @Override()
+			 * @SuppressWarnings("all")
+			 * @SuppressWarnings({"all", "unused"})
+			 * @SuppressWarnings(value = "all")
+			 * @SuppressWarnings(value = {"all", "unused"})
+			 * @EqualsAndHashCode(callSuper=true, of="id")
+			 * 
+			 * Currently, we only seem to correctly support:
+			 * @Override
+			 * @Override() N.B. We lose the parentheses here, since there are no values. No big deal.
+			 * @SuppressWarnings("all")
+			 */
+			for (org.eclipse.jdt.core.dom.Annotation annotation : annotations) {
+				List<String> values = new ArrayList<String>();
+				if (annotation.isSingleMemberAnnotation()) {
+					org.eclipse.jdt.core.dom.SingleMemberAnnotation smAnn = (org.eclipse.jdt.core.dom.SingleMemberAnnotation) annotation;
+					values.add(smAnn.getValue().toString());
+				} else if (annotation.isNormalAnnotation()) {
+					org.eclipse.jdt.core.dom.NormalAnnotation normalAnn = (org.eclipse.jdt.core.dom.NormalAnnotation) annotation;
+					for (Object value : normalAnn.values()) values.add(value.toString());
+				}
+				
+				signature.append("@").append(annotation.resolveTypeBinding().getQualifiedName());
+				if (!values.isEmpty()) {
+					signature.append("(");
+					boolean first = true;
+					for (String string : values) {
+						if (!first) signature.append(", ");
+						first = false;
+						signature.append('"').append(string).append('"');
+					}
+					signature.append(")");
+				}
+				signature.append(" ");
+			}
+		}
+		
+		public static org.eclipse.jdt.core.dom.MethodDeclaration getRealMethodDeclarationNode(org.eclipse.jdt.core.IMethod sourceMethod, org.eclipse.jdt.core.dom.CompilationUnit cuUnit) throws JavaModelException {
+			MethodDeclaration methodDeclarationNode = ASTNodeSearchUtil.getMethodDeclarationNode(sourceMethod, cuUnit);
+			if (isGenerated(methodDeclarationNode)) {
+				IType declaringType = sourceMethod.getDeclaringType();
+				Stack<IType> typeStack = new Stack<IType>();
+				while (declaringType != null) {
+					typeStack.push(declaringType);
+					declaringType = declaringType.getDeclaringType();
+				}
+				
+				IType rootType = typeStack.pop();
+				org.eclipse.jdt.core.dom.AbstractTypeDeclaration typeDeclaration = findTypeDeclaration(rootType, cuUnit.types());
+				while (!typeStack.isEmpty() && typeDeclaration != null) {
+					typeDeclaration = findTypeDeclaration(typeStack.pop(), typeDeclaration.bodyDeclarations());
+				}
+				
+				if (typeStack.isEmpty() && typeDeclaration != null) {
+					String methodName = sourceMethod.getElementName();
+					for (Object declaration : typeDeclaration.bodyDeclarations()) {
+						if (declaration instanceof org.eclipse.jdt.core.dom.MethodDeclaration) {
+							org.eclipse.jdt.core.dom.MethodDeclaration methodDeclaration = (org.eclipse.jdt.core.dom.MethodDeclaration) declaration;
+							if (methodDeclaration.getName().toString().equals(methodName)) {
+								return methodDeclaration;
+							}
+						}
+					}
+				}
+			}
+			return methodDeclarationNode;
+		}
+		
+		// part of getRealMethodDeclarationNode
+		public static org.eclipse.jdt.core.dom.AbstractTypeDeclaration findTypeDeclaration(IType searchType, List<?> nodes) {
+			for (Object object : nodes) {
+				if (object instanceof org.eclipse.jdt.core.dom.AbstractTypeDeclaration) {
+					org.eclipse.jdt.core.dom.AbstractTypeDeclaration typeDeclaration = (org.eclipse.jdt.core.dom.AbstractTypeDeclaration) object;
+					if (typeDeclaration.getName().toString().equals(searchType.getElementName()))
+						return typeDeclaration;
+				}
+			}
+			return null;
+		}
+		
+		public static int getSourceEndFixed(int sourceEnd, org.eclipse.jdt.internal.compiler.ast.ASTNode node) throws Exception {
+			if (sourceEnd == -1) {
+				org.eclipse.jdt.internal.compiler.ast.ASTNode object = (org.eclipse.jdt.internal.compiler.ast.ASTNode)node.getClass().getField("$generatedBy").get(node);
+				if (object != null) {
+					return object.sourceEnd;
+				}
+			}
+			return sourceEnd;
+		}
+		
+		public static int fixRetrieveStartingCatchPosition(int original, int start) {
+			return original == -1 ? start : original;
+		}
+		
+		public static int fixRetrieveIdentifierEndPosition(int original, int end) {
+			return original == -1 ? end : original;
+		}
+		
+		public static int fixRetrieveEllipsisStartPosition(int original, int end) {
+			return original == -1 ? end : original;
+		}
+		
+		public static int fixRetrieveRightBraceOrSemiColonPosition(int original, int end) {
+			 return original == -1 ? end : original;  // Need to fix: see issue 325.
+		}
+		
+		public static final int ALREADY_PROCESSED_FLAG = 0x800000;  //Bit 24
+		
+		public static boolean checkBit24(Object node) throws Exception {
+			int bits = (Integer)(node.getClass().getField("bits").get(node));
+			return (bits & ALREADY_PROCESSED_FLAG) != 0;
+		}
+		
+		public static boolean skipRewritingGeneratedNodes(org.eclipse.jdt.core.dom.ASTNode node) throws Exception {
+			return ((Boolean) node.getClass().getField("$isGenerated").get(node)).booleanValue();
+		}
+		
+		public static void setIsGeneratedFlag(org.eclipse.jdt.core.dom.ASTNode domNode,
+				org.eclipse.jdt.internal.compiler.ast.ASTNode internalNode) throws Exception {
+			
+			if (internalNode == null || domNode == null) return;
+			boolean isGenerated = EclipseAugments.ASTNode_generatedBy.get(internalNode) != null;
+			if (isGenerated) domNode.getClass().getField("$isGenerated").set(domNode, true);
+		}
+		
+		public static void setIsGeneratedFlagForName(org.eclipse.jdt.core.dom.Name name, Object internalNode) throws Exception {
+			if (internalNode instanceof org.eclipse.jdt.internal.compiler.ast.ASTNode) {
+				boolean isGenerated = EclipseAugments.ASTNode_generatedBy.get((org.eclipse.jdt.internal.compiler.ast.ASTNode) internalNode) != null;
+				if (isGenerated) name.getClass().getField("$isGenerated").set(name, true);
+			}
+		}
+		
+		public static RewriteEvent[] listRewriteHandleGeneratedMethods(RewriteEvent parent) {
+			RewriteEvent[] children = parent.getChildren();
+			List<RewriteEvent> newChildren = new ArrayList<RewriteEvent>();
+			List<RewriteEvent> modifiedChildren = new ArrayList<RewriteEvent>();
+			for (int i = 0; i < children.length; i++) {
+				RewriteEvent child = children[i];
+				boolean isGenerated = isGenerated((org.eclipse.jdt.core.dom.ASTNode) child.getOriginalValue());
+				if (isGenerated) {
+					boolean isReplacedOrRemoved = child.getChangeKind() == RewriteEvent.REPLACED || child.getChangeKind() == RewriteEvent.REMOVED;
+					boolean convertingFromMethod = child.getOriginalValue() instanceof org.eclipse.jdt.core.dom.MethodDeclaration;
+					if (isReplacedOrRemoved && convertingFromMethod && child.getNewValue() != null) {
+						modifiedChildren.add(new NodeRewriteEvent(null, child.getNewValue()));
+					}
+				} else {
+					newChildren.add(child);
+				}
+			}
+			// Since Eclipse doesn't honor the "insert at specified location" for already existing members,
+			// we'll just add them last
+			newChildren.addAll(modifiedChildren);
+			return newChildren.toArray(new RewriteEvent[newChildren.size()]);
+		}
+		
+		public static int getTokenEndOffsetFixed(TokenScanner scanner, int token, int startOffset, Object domNode) throws CoreException {
+			boolean isGenerated = false;
+			try {
+				isGenerated = (Boolean) domNode.getClass().getField("$isGenerated").get(domNode);
+			} catch (Exception e) {
+				// If this fails, better to break some refactor scripts than to crash eclipse.
+			}
+			if (isGenerated) return -1;
+			return scanner.getTokenEndOffset(token, startOffset);
+		}
+		
+		public static IMethod[] removeGeneratedMethods(IMethod[] methods) throws Exception {
+			List<IMethod> result = new ArrayList<IMethod>();
+			for (IMethod m : methods) {
+				if (m.getNameRange().getLength() > 0 && !m.getNameRange().equals(m.getSourceRange())) result.add(m);
+			}
+			return result.size() == methods.length ? methods : result.toArray(new IMethod[result.size()]);
+		}
+		
+		public static SimpleName[] removeGeneratedSimpleNames(SimpleName[] in) throws Exception {
+			Field f = SimpleName.class.getField("$isGenerated");
+			
+			int count = 0;
+			for (int i = 0; i < in.length; i++) {
+				if (in[i] == null || !((Boolean)f.get(in[i])).booleanValue()) count++;
+			}
+			if (count == in.length) return in;
+			SimpleName[] newSimpleNames = new SimpleName[count];
+			count = 0;
+			for (int i = 0; i < in.length; i++) {
+				if (in[i] == null || !((Boolean)f.get(in[i])).booleanValue()) newSimpleNames[count++] = in[i];
+			}
+			return newSimpleNames;
+		}
+		
+		public static Annotation[] convertAnnotations(Annotation[] out, IAnnotatable annotatable) {
+			IAnnotation[] in;
+			
+			try {
+				in = annotatable.getAnnotations();
+			} catch (Exception e) {
+				return out;
+			}
+			
+			if (out == null) return null;
+			int toWrite = 0;
+			
+			for (int idx = 0; idx < out.length; idx++) {
+				String oName = new String(out[idx].type.getLastToken());
+				boolean found = false;
+				for (IAnnotation i : in) {
+					String name = i.getElementName();
+					int li = name.lastIndexOf('.');
+					if (li > -1) name = name.substring(li + 1);
+					if (name.equals(oName)) {
+						found = true;
+						break;
+					}
+				}
+				if (!found) out[idx] = null;
+				else toWrite++;
+			}
+			
+			Annotation[] replace = out;
+			if (toWrite < out.length) {
+				replace = new Annotation[toWrite];
+				int idx = 0;
+				for (int i = 0; i < out.length; i++) {
+					if (out[i] == null) continue;
+					replace[idx++] = out[i];
+				}
+			}
+			
+			return replace;
+		}
+	}
+}
diff --git a/src/launch/lombok/launch/ShadowClassLoader.java b/src/launch/lombok/launch/ShadowClassLoader.java
index 79809b2f..b883bd71 100644
--- a/src/launch/lombok/launch/ShadowClassLoader.java
+++ b/src/launch/lombok/launch/ShadowClassLoader.java
@@ -211,24 +211,26 @@ class ShadowClassLoader extends ClassLoader {
 		
 		if (!location.isFile() || !location.canRead()) return null;
 		
-		String absolutePath; {
+		File absoluteFile; {
 			try {
-				absolutePath = location.getCanonicalPath();
+				absoluteFile = location.getCanonicalFile();
 			} catch (Exception e) {
-				absolutePath = location.getAbsolutePath();
+				absoluteFile = location.getAbsoluteFile();
 			}
 		}
-		List<String> jarContents = getOrMakeJarListing(absolutePath);
+		List<String> jarContents = getOrMakeJarListing(absoluteFile.getAbsolutePath());
+		
+		String absoluteUri = absoluteFile.toURI().toString();
 		
 		try {
 			if (jarContents.contains(altName)) {
-				return new URI("jar:file:" + absolutePath + "!/" + altName).toURL();
+				return new URI("jar:" + absoluteUri + "!/" + altName).toURL();
 			}
 		} catch (Exception e) {}
 		
 		try {
 			if (jarContents.contains(name)) {
-				return new URI("jar:file:" + absolutePath + "!/" + name).toURL();
+				return new URI("jar:" + absoluteUri + "!/" + name).toURL();
 			}
 		} catch(Exception e) {}