Fixed merge conflict in changelog

43 files changed, 545 insertions, 77 deletions

diff --git a/build.xml b/build.xml
index 99960bd2..9de92d59 100644
--- a/build.xml
+++ b/build.xml
@@ -27,7 +27,7 @@ the common tasks and can be called on to run the main aspects of all the sub-scr
 	
 	<property name="credentialsFile" value="google.properties" />
 	<property name="build.compiler" value="javac1.6" />
-	<property name="ivy.retrieve.pattern" value="lib/[conf]/[artifact].[ext]" />
+	<property name="ivy.retrieve.pattern" value="lib/[conf]/[organisation]-[artifact].[ext]" />
 	<available file="lib/ivyplusplus.jar" property="ivyplusplus.available" />
 	
 	<path id="build.path">
@@ -196,7 +196,7 @@ the common tasks and can be called on to run the main aspects of all the sub-scr
 	<target name="dist" description="Builds THE lombok.jar file which contains everything." depends="version, compile">
 		<mkdir dir="dist" />
 		<copy file="doc/changelog.markdown" tofile="build/changelog.txt" />
-		<taskdef name="jarjar" classname="com.tonicsystems.jarjar.JarJarTask" classpath="lib/build/jarjar.jar" />
+		<taskdef name="jarjar" classname="com.tonicsystems.jarjar.JarJarTask" classpath="lib/build/com.googlecode.jarjar-jarjar.jar" />
 		<jarjar destfile="dist/lombok-${lombok.version}.jar">
 			<fileset dir="build/lombok">
 				<exclude name="com/sun/tools/javac/**"/>
@@ -271,21 +271,14 @@ the common tasks and can be called on to run the main aspects of all the sub-scr
 			<settings>
 				<url url="http://projectlombok.org/downloads/lombok.eclipse.settings" />
 			</settings>
-			<apt location="lib/build/spi.jar" />
+			<apt location="lib/build/projectlombok.org-spi.jar" />
 		</ivy:eclipsegen>
 		
-		<condition property="startOnFirstThread" value="-XstartOnFirstThread" else="">
-			<os family="mac" />
-		</condition>
-		
 		<copy
 				file="buildScripts/eclipse-debug-target.template"
 				tofile="LombokizedEclipse.launch"
 				preservelastmodified="true"
 				overwrite="true">
-			<filterset>
-				<filter token="START_ON_FIRST_THREAD" value="${startOnFirstThread}" />
-			</filterset>
 		</copy>
 	</target>
 	
@@ -306,7 +299,7 @@ the common tasks and can be called on to run the main aspects of all the sub-scr
 	</target>
 	
 	<target name="test-ecj" depends="dist, contrib" unless="tests.skip">
-		<java jar="lib/ecj/ecj.jar" fork="true" failonerror="true">
+		<java jar="lib/ecj/org.eclipse.custom-ecj.jar" fork="true" failonerror="true">
 			<jvmarg value="-javaagent:dist/lombok.jar=ecj" />
 			<arg value="-source" />
 			<arg value="1.6" />
diff --git a/buildScripts/eclipse-debug-target.template b/buildScripts/eclipse-debug-target.template
index 033f8197..bb45cd69 100644
--- a/buildScripts/eclipse-debug-target.template
+++ b/buildScripts/eclipse-debug-target.template
@@ -21,7 +21,7 @@
 <stringAttribute key="org.eclipse.jdt.launching.JRE_CONTAINER" value="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.6"/>
 <stringAttribute key="org.eclipse.jdt.launching.PROGRAM_ARGUMENTS" value="-os ${target.os} -ws ${target.ws} -arch ${target.arch} -nl ${target.nl}"/>
 <stringAttribute key="org.eclipse.jdt.launching.SOURCE_PATH_PROVIDER" value="org.eclipse.pde.ui.workbenchClasspathProvider"/>
-<stringAttribute key="org.eclipse.jdt.launching.VM_ARGUMENTS" value="-Xms40m -Xmx512m -XX:MaxPermSize=256m @START_ON_FIRST_THREAD@ -Dorg.eclipse.swt.internal.carbon.smallFonts -javaagent:${project_loc:lombok}/dist/lombok.jar -Xbootclasspath/a:${project_loc:lombok}/dist/lombok.jar -Dlombok.patcher.patchDebugDir=${project_loc:lombok}/debug/patchedClasses"/>
+<stringAttribute key="org.eclipse.jdt.launching.VM_ARGUMENTS" value="-Xms40m -Xmx512m -XX:MaxPermSize=256m -Dorg.eclipse.swt.internal.carbon.smallFonts -javaagent:${project_loc:lombok}/dist/lombok.jar -Xbootclasspath/a:${project_loc:lombok}/dist/lombok.jar -Dlombok.patcher.patchDebugDir=${project_loc:lombok}/debug/patchedClasses"/>
 <stringAttribute key="pde.version" value="3.3"/>
 <stringAttribute key="product" value="org.eclipse.sdk.ide"/>
 <booleanAttribute key="show_selected_only" value="false"/>
diff --git a/buildScripts/ivy.xml b/buildScripts/ivy.xml
index b1440db5..fd6c503a 100644
--- a/buildScripts/ivy.xml
+++ b/buildScripts/ivy.xml
@@ -17,6 +17,7 @@
 		
 		<dependency org="junit" name="junit" rev="4.8.2" conf="test->default; contrib->sources" />
 		<dependency org="log4j" name="log4j" rev="1.2.16" conf="test->default; contrib->sources" />
+		<dependency org="org.apache.logging.log4j" name="log4j-api" rev="2.0-beta4" conf="test->default; contrib->sources" />
 		<dependency org="commons-logging" name="commons-logging" rev="1.1.1" conf="test->default; contrib->sources"/>
 		<dependency org="org.slf4j" name="slf4j-api" rev="1.6.1" conf="test->default; contrib->sources"/>
 		<dependency org="org.slf4j" name="slf4j-ext" rev="1.6.1" conf="test->default; contrib->sources"/>
diff --git a/doc/changelog.markdown b/doc/changelog.markdown
index a415cd01..043e524e 100644
--- a/doc/changelog.markdown
+++ b/doc/changelog.markdown
@@ -4,6 +4,10 @@ Lombok Changelog
 ### v0.11.7 (Edgy Guinea Pig)
 * CHANGE: {Experimental} The experimental `@Value` feature no longer implies the also experimental `@Wither`. If you like your `@Value` classes to make withers, add `@Wither` to the class right next to `@Value`.
 * FEATURE: {Experimental} Reintroduced `onMethod`, `onConstructor` and `onParam` to `@Getter`, `@Setter`, `@Wither`, and `@XArgsConstructor`. These parameters allow you to add annotations to the methods/constructors that lombok will generate. This is a workaround feature: The stability of the feature on future versions of javac is not guaranteed, and if a better way to implement this feature is found, this feature's current incarnation will be removed without a reasonable period of deprecation. [Documentation on the onX feature](http://projectlombok.org/features/experimental/onX.html)
+* FEATURE: Added support for Log4j v2.0 via `@Log4j2` [Issue #432](http://code.google.com/p/projectlombok/issues/detail?id=432)
+* ENHANCEMENT: The Lombok installer can now find and install lombok into [JBoss Developer Studio](http://www.redhat.com/products/jbossenterprisemiddleware/developer-studio/). The installer will now also look for eclipse and eclipse variants in your home directory. [Issue #434](http://code.google.com/p/projectlombok/issues/detail?id=432)
+* BUGFIX: `@ExtensionMethods` no longer causes `VerifyError` exceptions when running eclipse-compiled code if extension methods are called on expressions which are method calls whose return type is a type variable. For example, `someList.get(i).extensionMethod()` would fail that way. [Issue #436](http://code.google.com/p/projectlombok/issues/detail?id=436)
+* BUGFIX: java 7's try-with-resources statement did not delombok correctly. [Issue #459](http://code.google.com/p/projectlombok/issues/detail?id=459)
 
 ### v0.11.6 (October 30th, 2012)
 * FEATURE: Lombok can be disabled entirely for any given compile run by using JVM switch `-Dlombok.disable`. This might be useful for code style checkers and such.
diff --git a/src/core/lombok/eclipse/EclipseAnnotationHandler.java b/src/core/lombok/eclipse/EclipseAnnotationHandler.java
index 84304339..ca9965f7 100644
--- a/src/core/lombok/eclipse/EclipseAnnotationHandler.java
+++ b/src/core/lombok/eclipse/EclipseAnnotationHandler.java
@@ -29,7 +29,7 @@ import lombok.core.SpiLoadUtil;
  * 
  * You MUST replace 'T' with a specific annotation type, such as:
  * 
- * {@code public class HandleGetter implements EclipseAnnotationHandler<Getter>}
+ * {@code public class HandleGetter extends EclipseAnnotationHandler<Getter>}
  * 
  * Because this generics parameter is inspected to figure out which class you're interested in.
  * 
diff --git a/src/core/lombok/eclipse/handlers/HandleLog.java b/src/core/lombok/eclipse/handlers/HandleLog.java
index bffe2d62..2e7b4475 100644
--- a/src/core/lombok/eclipse/handlers/HandleLog.java
+++ b/src/core/lombok/eclipse/handlers/HandleLog.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2010-2012 The Project Lombok Authors.
+ * 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
@@ -178,6 +178,16 @@ public class HandleLog {
 	}
 	
 	/**
+	 * Handles the {@link lombok.extern.log4j.Log4j2} annotation for Eclipse.
+	 */
+	@ProviderFor(EclipseAnnotationHandler.class)
+	public static class HandleLog4j2Log extends EclipseAnnotationHandler<lombok.extern.log4j.Log4j2> {
+		@Override public void handle(AnnotationValues<lombok.extern.log4j.Log4j2> annotation, Annotation source, EclipseNode annotationNode) {
+			processAnnotation(LoggingFramework.LOG4J2, annotation, source, annotationNode);
+		}
+	}
+	
+	/**
 	 * Handles the {@link lombok.extern.slf4j.Slf4j} annotation for Eclipse.
 	 */
 	@ProviderFor(EclipseAnnotationHandler.class)
@@ -224,6 +234,9 @@ public class HandleLog {
 		// private static final org.apache.log4j.Logger log = org.apache.log4j.Logger.getLogger(TargetType.class);
 		LOG4J("org.apache.log4j.Logger", "org.apache.log4j.Logger", "getLogger", "@Log4j"),
 
+		// private static final org.apache.logging.log4j.Logger log = org.apache.logging.log4j.LogManager.getLogger(TargetType.class);
+		LOG4J2("org.apache.logging.log4j.Logger", "org.apache.logging.log4j.LogManager", "getLogger", "@Log4j2"),
+
 		// private static final org.slf4j.Logger log = org.slf4j.LoggerFactory.getLogger(TargetType.class);
 		SLF4J("org.slf4j.Logger", "org.slf4j.LoggerFactory", "getLogger", "@Slf4j"),
 		
diff --git a/src/core/lombok/eclipse/handlers/HandleSneakyThrows.java b/src/core/lombok/eclipse/handlers/HandleSneakyThrows.java
index b7c8a5d8..aa78ca3b 100644
--- a/src/core/lombok/eclipse/handlers/HandleSneakyThrows.java
+++ b/src/core/lombok/eclipse/handlers/HandleSneakyThrows.java
@@ -40,6 +40,8 @@ import org.eclipse.jdt.internal.compiler.ast.Annotation;
 import org.eclipse.jdt.internal.compiler.ast.Argument;
 import org.eclipse.jdt.internal.compiler.ast.ArrayInitializer;
 import org.eclipse.jdt.internal.compiler.ast.Block;
+import org.eclipse.jdt.internal.compiler.ast.ConstructorDeclaration;
+import org.eclipse.jdt.internal.compiler.ast.ExplicitConstructorCall;
 import org.eclipse.jdt.internal.compiler.ast.Expression;
 import org.eclipse.jdt.internal.compiler.ast.MemberValuePair;
 import org.eclipse.jdt.internal.compiler.ast.MessageSend;
@@ -147,7 +149,21 @@ public class HandleSneakyThrows extends EclipseAnnotationHandler<SneakyThrows> {
 			return;
 		}
 		
-		if (method.statements == null) return;
+		if (method.statements == null || method.statements.length == 0) {
+			boolean hasConstructorCall = false;
+			if (method instanceof ConstructorDeclaration) {
+				ExplicitConstructorCall constructorCall = ((ConstructorDeclaration) method).constructorCall;
+				hasConstructorCall = constructorCall != null && !constructorCall.isImplicitSuper() && !constructorCall.isImplicitThis();
+			}
+			
+			if (hasConstructorCall) {
+				annotation.addWarning("Calls to sibling / super constructors are always excluded from @SneakyThrows; @SneakyThrows has been ignored because there is no other code in this constructor.");
+			} else {
+				annotation.addWarning("This method or constructor is empty; @SneakyThrows has been ignored.");
+			}
+			
+			return;
+		}
 		
 		Statement[] contents = method.statements;
 		
@@ -160,9 +176,9 @@ public class HandleSneakyThrows extends EclipseAnnotationHandler<SneakyThrows> {
 	}
 	
 	private Statement buildTryCatchBlock(Statement[] contents, DeclaredException exception, ASTNode source, AbstractMethodDeclaration method) {
-		int methodStart =  method.bodyStart;
-		int methodEnd =  method.bodyEnd;
-		long methodPosEnd = methodEnd << 32 | (methodEnd & 0xFFFFFFFFL);
+		int methodStart = method.bodyStart;
+		int methodEnd = method.bodyEnd;
+		long methodPosEnd = ((long) methodEnd) << 32 | (methodEnd & 0xFFFFFFFFL);
 		
 		TryStatement tryStatement = new TryStatement();
 		setGeneratedBy(tryStatement, source);
diff --git a/src/core/lombok/eclipse/handlers/HandleToString.java b/src/core/lombok/eclipse/handlers/HandleToString.java
index 75d4acef..d864153f 100644
--- a/src/core/lombok/eclipse/handlers/HandleToString.java
+++ b/src/core/lombok/eclipse/handlers/HandleToString.java
@@ -209,21 +209,25 @@ public class HandleToString extends EclipseAnnotationHandler<ToString> {
 		}
 		
 		for (EclipseNode field : fields) {
-			TypeReference fType = getFieldType(field, fieldAccess);
+			TypeReference fieldType = getFieldType(field, fieldAccess);
 			Expression fieldAccessor = createFieldAccessor(field, fieldAccess, source);
 			
+			// The distinction between primitive and object will be useful if we ever add a 'hideNulls' option.
+			boolean fieldBaseTypeIsPrimitive = BUILT_IN_TYPES.contains(new String(fieldType.getLastToken()));
+			boolean fieldIsPrimitive = fieldType.dimensions() == 0 && fieldBaseTypeIsPrimitive;
+			boolean fieldIsPrimitiveArray = fieldType.dimensions() == 1 && fieldBaseTypeIsPrimitive;
+			boolean fieldIsObjectArray = fieldType.dimensions() > 0 && !fieldIsPrimitiveArray;
+			@SuppressWarnings("unused")
+			boolean fieldIsObject = !fieldIsPrimitive && !fieldIsPrimitiveArray && !fieldIsObjectArray;
+			
 			Expression ex;
-			if (fType.dimensions() > 0) {
+			if (fieldIsPrimitiveArray || fieldIsObjectArray) {
 				MessageSend arrayToString = new MessageSend();
 				arrayToString.sourceStart = pS; arrayToString.sourceEnd = pE;
 				arrayToString.receiver = generateQualifiedNameRef(source, TypeConstants.JAVA, TypeConstants.UTIL, "Arrays".toCharArray());
 				arrayToString.arguments = new Expression[] { fieldAccessor };
 				setGeneratedBy(arrayToString.arguments[0], source);
-				if (fType.dimensions() > 1 || !BUILT_IN_TYPES.contains(new String(fType.getLastToken()))) {
-					arrayToString.selector = "deepToString".toCharArray();
-				} else {
-					arrayToString.selector = "toString".toCharArray();
-				}
+				arrayToString.selector = (fieldIsObjectArray ? "deepToString" : "toString").toCharArray();
 				ex = arrayToString;
 			} else {
 				ex = fieldAccessor;
diff --git a/src/core/lombok/extern/apachecommons/CommonsLog.java b/src/core/lombok/extern/apachecommons/CommonsLog.java
index f178ae05..024e3744 100644
--- a/src/core/lombok/extern/apachecommons/CommonsLog.java
+++ b/src/core/lombok/extern/apachecommons/CommonsLog.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2010-2012 The Project Lombok Authors.
+ * 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
@@ -52,6 +52,7 @@ import java.lang.annotation.Target;
  * @see org.apache.commons.logging.LogFactory#getLog(java.lang.Class) org.apache.commons.logging.LogFactory.getLog(Class target)
  * @see lombok.extern.java.Log &#64;Log
  * @see lombok.extern.log4j.Log4j &#64;Log4j
+ * @see lombok.extern.log4j.Log4j2 &#64;Log4j2
  * @see lombok.extern.slf4j.Slf4j &#64;Slf4j
  * @see lombok.extern.slf4j.XSlf4j &#64;XSlf4j
  */
diff --git a/src/core/lombok/extern/java/Log.java b/src/core/lombok/extern/java/Log.java
index 90c62956..7ae4e07b 100644
--- a/src/core/lombok/extern/java/Log.java
+++ b/src/core/lombok/extern/java/Log.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2010-2012 The Project Lombok Authors.
+ * 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
@@ -51,6 +51,7 @@ import java.lang.annotation.Target;
  * @see java.util.logging.Logger#getLogger(java.lang.String) java.util.logging.Logger.getLogger(String name)
  * @see lombok.extern.apachecommons.CommonsLog &#64;CommonsLog
  * @see lombok.extern.log4j.Log4j &#64;Log4j
+ * @see lombok.extern.log4j.Log4j2 &#64;Log4j2
  * @see lombok.extern.slf4j.Slf4j &#64;Slf4j
  * @see lombok.extern.slf4j.XSlf4j &#64;XSlf4j
  */
diff --git a/src/core/lombok/extern/log4j/Log4j.java b/src/core/lombok/extern/log4j/Log4j.java
index 9cfc5839..29e1b27c 100644
--- a/src/core/lombok/extern/log4j/Log4j.java
+++ b/src/core/lombok/extern/log4j/Log4j.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2010-2012 The Project Lombok Authors.
+ * 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
@@ -50,6 +50,7 @@ import java.lang.annotation.Target;
  * 
  * @see org.apache.log4j.Logger org.apache.log4j.Logger
  * @see org.apache.log4j.Logger#getLogger(java.lang.Class) org.apache.log4j.Logger.getLogger(Class target)
+ * @see lombok.extern.log4j.Log4j2 &#64;Log4j2
  * @see lombok.extern.apachecommons.CommonsLog &#64;CommonsLog
  * @see lombok.extern.java.Log &#64;Log
  * @see lombok.extern.slf4j.Slf4j &#64;Slf4j
diff --git a/src/core/lombok/extern/log4j/Log4j2.java b/src/core/lombok/extern/log4j/Log4j2.java
new file mode 100644
index 00000000..2a0f09e1
--- /dev/null
+++ b/src/core/lombok/extern/log4j/Log4j2.java
@@ -0,0 +1,62 @@
+/*
+ * Copyright (C) 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.extern.log4j;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Causes lombok to generate a logger field.
+ * <p>
+ * Complete documentation is found at <a href="http://projectlombok.org/features/Log.html">the project lombok features page for lombok log annotations</a>.
+ * <p>
+ * Example:
+ * <pre>
+ * &#64;Log4j2
+ * public class LogExample {
+ * }
+ * </pre>
+ * 
+ * will generate:
+ * 
+ * <pre>
+ * public class LogExample {
+ *     private static final org.apache.logging.log4j.Logger log = org.apache.logging.log4j.Logger.getLogger(LogExample.class);
+ * }
+ * </pre>
+ * 
+ * This annotation is valid for classes and enumerations.<br />
+ * 
+ * @see org.apache.logging.log4j.Logger org.apache.logging.log4j.Logger
+ * @see org.apache.logging.log4j.LogManager#getLogger(java.lang.Class) org.apache.logging.log4j.LogManager.getLogger(Class target)
+ * @see lombok.extern.log4j.Log4j &#64;Log4j
+ * @see lombok.extern.apachecommons.CommonsLog &#64;CommonsLog
+ * @see lombok.extern.java.Log &#64;Log
+ * @see lombok.extern.slf4j.Slf4j &#64;Slf4j
+ * @see lombok.extern.slf4j.XSlf4j &#64;XSlf4j
+ */
+@Retention(RetentionPolicy.SOURCE)
+@Target(ElementType.TYPE)
+public @interface Log4j2 {
+}
\ No newline at end of file
diff --git a/src/core/lombok/extern/slf4j/Slf4j.java b/src/core/lombok/extern/slf4j/Slf4j.java
index 14dbcba6..45942971 100644
--- a/src/core/lombok/extern/slf4j/Slf4j.java
+++ b/src/core/lombok/extern/slf4j/Slf4j.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2010-2012 The Project Lombok Authors.
+ * 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
@@ -51,6 +51,7 @@ import java.lang.annotation.Target;
  * @see lombok.extern.apachecommons.CommonsLog &#64;CommonsLog
  * @see lombok.extern.java.Log &#64;Log
  * @see lombok.extern.log4j.Log4j &#64;Log4j
+ * @see lombok.extern.log4j.Log4j2 &#64;Log4j2
  */
 @Retention(RetentionPolicy.SOURCE)
 @Target(ElementType.TYPE)
diff --git a/src/core/lombok/extern/slf4j/XSlf4j.java b/src/core/lombok/extern/slf4j/XSlf4j.java
index bdf8a62c..599c68ab 100644
--- a/src/core/lombok/extern/slf4j/XSlf4j.java
+++ b/src/core/lombok/extern/slf4j/XSlf4j.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2012 The Project Lombok Authors.
+ * Copyright (C) 2012-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
@@ -51,6 +51,7 @@ import java.lang.annotation.Target;
  * @see lombok.extern.apachecommons.CommonsLog &#64;CommonsLog
  * @see lombok.extern.java.Log &#64;Log
  * @see lombok.extern.log4j.Log4j &#64;Log4j
+ * @see lombok.extern.log4j.Log4j2 &#64;Log4j2
  * @see lombok.extern.slf4j.Slf4j &#64;Slf4j
  */
 @Retention(RetentionPolicy.SOURCE)
diff --git a/src/core/lombok/javac/JavacAnnotationHandler.java b/src/core/lombok/javac/JavacAnnotationHandler.java
index 169e2026..a86aa6c6 100644
--- a/src/core/lombok/javac/JavacAnnotationHandler.java
+++ b/src/core/lombok/javac/JavacAnnotationHandler.java
@@ -33,7 +33,7 @@ import com.sun.tools.javac.tree.JCTree.JCAnnotation;
  * 
  * You MUST replace 'T' with a specific annotation type, such as:
  * 
- * {@code public class HandleGetter implements JavacAnnotationHandler<Getter>}
+ * {@code public class HandleGetter extends JavacAnnotationHandler<Getter>}
  * 
  * Because this generics parameter is inspected to figure out which class you're interested in.
  * 
diff --git a/src/core/lombok/javac/handlers/HandleLog.java b/src/core/lombok/javac/handlers/HandleLog.java
index 62a55c44..35a32be5 100644
--- a/src/core/lombok/javac/handlers/HandleLog.java
+++ b/src/core/lombok/javac/handlers/HandleLog.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2010-2012 The Project Lombok Authors.
+ * 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
@@ -82,7 +82,7 @@ public class HandleLog {
 	private static boolean createField(LoggingFramework framework, JavacNode typeNode, JCFieldAccess loggingType, JCTree source) {
 		TreeMaker maker = typeNode.getTreeMaker();
 		
-		// 	private static final <loggerType> log = <factoryMethod>(<parameter>);
+		// private static final <loggerType> log = <factoryMethod>(<parameter>);
 		JCExpression loggerType = chainDotsString(typeNode, framework.getLoggerTypeName());
 		JCExpression factoryMethod = chainDotsString(typeNode, framework.getLoggerFactoryMethodName());
 		
@@ -128,6 +128,16 @@ public class HandleLog {
 	}
 	
 	/**
+	 * Handles the {@link lombok.extern.log4j.Log4j2} annotation for javac.
+	 */
+	@ProviderFor(JavacAnnotationHandler.class)
+	public static class HandleLog4j2Log extends JavacAnnotationHandler<lombok.extern.log4j.Log4j2> {
+		@Override public void handle(AnnotationValues<lombok.extern.log4j.Log4j2> annotation, JCAnnotation ast, JavacNode annotationNode) {
+			processAnnotation(LoggingFramework.LOG4J2, annotation, annotationNode);
+		}
+	}
+	
+	/**
 	 * Handles the {@link lombok.extern.slf4j.Slf4j} annotation for javac.
 	 */
 	@ProviderFor(JavacAnnotationHandler.class)
@@ -163,6 +173,9 @@ public class HandleLog {
 		// private static final org.apache.log4j.Logger log = org.apache.log4j.Logger.getLogger(TargetType.class);
 		LOG4J(lombok.extern.log4j.Log4j.class, "org.apache.log4j.Logger", "org.apache.log4j.Logger.getLogger"),
 		
+		// private static final org.apache.logging.log4j.Logger log = org.apache.logging.log4j.LogManager.getLogger(TargetType.class);
+		LOG4J2(lombok.extern.log4j.Log4j2.class, "org.apache.logging.log4j.Logger", "org.apache.logging.log4j.LogManager.getLogger"),
+		
 		// private static final org.slf4j.Logger log = org.slf4j.LoggerFactory.getLogger(TargetType.class);
 		SLF4J(lombok.extern.slf4j.Slf4j.class, "org.slf4j.Logger", "org.slf4j.LoggerFactory.getLogger"),
 		
diff --git a/src/core/lombok/javac/handlers/HandleSneakyThrows.java b/src/core/lombok/javac/handlers/HandleSneakyThrows.java
index a5bd74e7..c2394fc8 100644
--- a/src/core/lombok/javac/handlers/HandleSneakyThrows.java
+++ b/src/core/lombok/javac/handlers/HandleSneakyThrows.java
@@ -84,13 +84,20 @@ public class HandleSneakyThrows extends JavacAnnotationHandler<SneakyThrows> {
 			return;
 		}
 		
-		if (method.body == null) return;
-		if (method.body.stats.isEmpty()) return;
+		if (method.body == null || method.body.stats.isEmpty()) {
+			generateEmptyBlockWarning(methodNode, annotation, false);
+			return;
+		}
 		
 		final JCStatement constructorCall = method.body.stats.get(0);
 		final boolean isConstructorCall = isConstructorCall(constructorCall);
 		List<JCStatement> contents = isConstructorCall ? method.body.stats.tail : method.body.stats;
 		
+		if (contents == null || contents.isEmpty()) {
+			generateEmptyBlockWarning(methodNode, annotation, true);
+			return;
+		}
+		
 		for (String exception : exceptions) {
 			contents = List.of(buildTryCatchBlock(methodNode, contents, exception, annotation.get()));
 		}
@@ -99,6 +106,14 @@ public class HandleSneakyThrows extends JavacAnnotationHandler<SneakyThrows> {
 		methodNode.rebuild();
 	}
 	
+	private void generateEmptyBlockWarning(JavacNode methodNode, JavacNode annotation, boolean hasConstructorCall) {
+		if (hasConstructorCall) {
+			annotation.addWarning("Calls to sibling / super constructors are always excluded from @SneakyThrows; @SneakyThrows has been ignored because there is no other code in this constructor.");
+		} else {
+			annotation.addWarning("This method or constructor is empty; @SneakyThrows has been ignored.");
+		}
+	}
+
 	private boolean isConstructorCall(final JCStatement supect) {
 		if (!(supect instanceof JCExpressionStatement)) return false;
 		final JCExpression supectExpression = ((JCExpressionStatement) supect).expr;
diff --git a/src/core/lombok/javac/handlers/HandleToString.java b/src/core/lombok/javac/handlers/HandleToString.java
index 520acf62..5b3c033c 100644
--- a/src/core/lombok/javac/handlers/HandleToString.java
+++ b/src/core/lombok/javac/handlers/HandleToString.java
@@ -198,18 +198,22 @@ public class HandleToString extends JavacAnnotationHandler<ToString> {
 		}
 		
 		for (JavacNode fieldNode : fields) {
-			JCVariableDecl field = (JCVariableDecl) fieldNode.get();
 			JCExpression expr;
 			
 			JCExpression fieldAccessor = createFieldAccessor(maker, fieldNode, fieldAccess);
 			
-			if (getFieldType(fieldNode, fieldAccess) instanceof JCArrayTypeTree) {
-				boolean multiDim = ((JCArrayTypeTree)field.vartype).elemtype instanceof JCArrayTypeTree;
-				boolean primitiveArray = ((JCArrayTypeTree)field.vartype).elemtype instanceof JCPrimitiveTypeTree;
-				boolean useDeepTS = multiDim || !primitiveArray;
-				
-				JCExpression hcMethod = chainDots(typeNode, "java", "util", "Arrays", useDeepTS ? "deepToString" : "toString");
-				expr = maker.Apply(List.<JCExpression>nil(), hcMethod, List.<JCExpression>of(fieldAccessor));
+			JCExpression fieldType = getFieldType(fieldNode, fieldAccess);
+			
+			// The distinction between primitive and object will be useful if we ever add a 'hideNulls' option.
+			boolean fieldIsPrimitive = fieldType instanceof JCPrimitiveTypeTree;
+			boolean fieldIsPrimitiveArray = fieldType instanceof JCArrayTypeTree && ((JCArrayTypeTree) fieldType).elemtype instanceof JCPrimitiveTypeTree;
+			boolean fieldIsObjectArray = !fieldIsPrimitiveArray && fieldType instanceof JCArrayTypeTree;
+			@SuppressWarnings("unused")
+			boolean fieldIsObject = !fieldIsPrimitive && !fieldIsPrimitiveArray && !fieldIsObjectArray;
+			
+			if (fieldIsPrimitiveArray || fieldIsObjectArray) {
+				JCExpression tsMethod = chainDots(typeNode, "java", "util", "Arrays", fieldIsObjectArray ? "deepToString" : "toString");
+				expr = maker.Apply(List.<JCExpression>nil(), tsMethod, List.<JCExpression>of(fieldAccessor));
 			} else expr = fieldAccessor;
 			
 			if (first) {
diff --git a/src/core/lombok/javac/handlers/JavacHandlerUtil.java b/src/core/lombok/javac/handlers/JavacHandlerUtil.java
index c2de5b05..e79dd5dc 100644
--- a/src/core/lombok/javac/handlers/JavacHandlerUtil.java
+++ b/src/core/lombok/javac/handlers/JavacHandlerUtil.java
@@ -305,6 +305,7 @@ public class JavacHandlerUtil {
 			return;
 		}
 		
+		parentNode.getAst().setChanged();
 		deleteImportFromCompilationUnit(annotation, annotationType.getName());
 	}
 	
diff --git a/src/delombok/lombok/delombok/PrettyCommentsPrinter.java b/src/delombok/lombok/delombok/PrettyCommentsPrinter.java
index 6e9a1c94..9c6a2bd7 100644
--- a/src/delombok/lombok/delombok/PrettyCommentsPrinter.java
+++ b/src/delombok/lombok/delombok/PrettyCommentsPrinter.java
@@ -22,6 +22,11 @@
  * CA 95054 USA or visit www.sun.com if you need additional information or
  * have any questions.
  */
+
+/*
+ * Code derived from com.sun.tools.javac.tree.Pretty, from the langtools project.
+ * A version can be found at, for example, http://hg.openjdk.java.net/jdk7/build/langtools
+ */
 package lombok.delombok;
 
 import static com.sun.tools.javac.code.Flags.ANNOTATION;
@@ -981,6 +986,29 @@ public class PrettyCommentsPrinter extends JCTree.Visitor {
     public void visitTry(JCTry tree) {
         try {
             print("try ");
+            List<?> resources = null;
+            try {
+                Field f = JCTry.class.getField("resources");
+                resources = (List<?>) f.get(tree);
+            } catch (Exception ignore) {
+                // In JDK6 and down this field does not exist; resources will retain its initializer value which is what we want.
+            }
+            
+            if (resources != null && resources.nonEmpty()) {
+                boolean first = true;
+                print("(");
+                for (Object var0 : resources) {
+                    JCTree var = (JCTree) var0;
+                    if (!first) {
+                        println();
+                        indent();
+                    }
+                    printStat(var);
+                    first = false;
+                }
+                print(") ");
+            }
+            
             printStat(tree.body);
             for (List<JCCatch> l = tree.catchers; l.nonEmpty(); l = l.tail) {
                 printStat(l.head);
diff --git a/src/eclipseAgent/lombok/eclipse/agent/PatchExtensionMethod.java b/src/eclipseAgent/lombok/eclipse/agent/PatchExtensionMethod.java
index 008e722a..a3d77055 100644
--- a/src/eclipseAgent/lombok/eclipse/agent/PatchExtensionMethod.java
+++ b/src/eclipseAgent/lombok/eclipse/agent/PatchExtensionMethod.java
@@ -236,10 +236,8 @@ public class PatchExtensionMethod {
 					for (int i = 0, iend = arguments.size(); i < iend; i++) {
 						Expression arg = arguments.get(i);
 						if (fixedBinding.parameters[i].isArrayType() != arg.resolvedType.isArrayType()) break;
-						if (arg.resolvedType.isArrayType()) {
-							if (arg instanceof MessageSend) {
-								((MessageSend) arg).valueCast = arg.resolvedType;
-							}
+						if (arg instanceof MessageSend) {
+							((MessageSend) arg).valueCast = arg.resolvedType;
 						}
 						if (!fixedBinding.parameters[i].isBaseType() && arg.resolvedType.isBaseType()) {
 							int id = arg.resolvedType.id;
diff --git a/src/installer/lombok/installer/eclipse/EclipseFinder.java b/src/installer/lombok/installer/eclipse/EclipseFinder.java
index 9fbcabbc..8a1a689a 100644
--- a/src/installer/lombok/installer/eclipse/EclipseFinder.java
+++ b/src/installer/lombok/installer/eclipse/EclipseFinder.java
@@ -64,14 +64,10 @@ public class EclipseFinder extends IdeFinder {
 	
 	/**
 	 * Returns a list of paths of Eclipse installations.
-	 * Eclipse installations are found by checking for the existence of 'eclipse.exe' in the following locations:
-	 * <ul>
-	 * <li>X:\*Program Files*\*Eclipse*</li>
-	 * <li>X:\*Eclipse*</li>
-	 * </ul>
 	 * 
-	 * Where 'X' is tried for all local disk drives, unless there's a problem calling fsutil, in which case only
-	 * C: is tried.
+	 * The search process works by scanning for each 'source dir' for either an eclipse installation or a folder containing the text returned
+	 * by getDirName(). If such a folder is found, this process is applied recursively. On windows, this process is run on each drive letter
+	 * which represents a physical hard disk. If the native windows API call to determine these drive letters fails, only 'C:' is checked.
 	 */
 	private List<String> getSourceDirsOnWindowsWithDriveLetters() {
 		List<String> driveLetters = asList("C");
@@ -83,12 +79,22 @@ public class EclipseFinder extends IdeFinder {
 		List<String> sourceDirs = new ArrayList<String>();
 		for (String letter : driveLetters) {
 			for (String possibleSource : getSourceDirsOnWindows()) {
-				sourceDirs.add(letter + ":" + possibleSource);
+				if (!isDriveSpecificOnWindows(possibleSource)) {
+					sourceDirs.add(letter + ":" + possibleSource);
+				}
 			}
 		}
+		for (String possibleSource : getSourceDirsOnWindows()) {
+			if (isDriveSpecificOnWindows(possibleSource)) sourceDirs.add(possibleSource);
+		}
+		
 		return sourceDirs;
 	}
 	
+	public boolean isDriveSpecificOnWindows(String path) {
+		return path.length() > 1 && path.charAt(1) == ':';
+	}
+	
 	protected List<String> getSourceDirsOnMac() {
 		return Arrays.asList("/Applications", System.getProperty("user.home", "."));
 	}
diff --git a/src/installer/lombok/installer/eclipse/JbdsFinder.java b/src/installer/lombok/installer/eclipse/JbdsFinder.java
new file mode 100644
index 00000000..2dfaacba
--- /dev/null
+++ b/src/installer/lombok/installer/eclipse/JbdsFinder.java
@@ -0,0 +1,70 @@
+/*
+ * Copyright (C) 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.installer.eclipse;
+
+import java.util.Arrays;
+import java.util.List;
+
+import lombok.installer.CorruptedIdeLocationException;
+import lombok.installer.IdeFinder;
+import lombok.installer.IdeLocation;
+
+import org.mangosdk.spi.ProviderFor;
+
+/**
+ * JBDS (JBoss Developer Studio) is an eclipse variant.
+ * Other than different executable names, it's the same as eclipse, as far as lombok support goes.
+ */
+@ProviderFor(IdeFinder.class)
+public class JbdsFinder extends EclipseFinder {
+	@Override protected IdeLocation createLocation(String guess) throws CorruptedIdeLocationException {
+		return new JbdsLocationProvider().create0(guess);
+	}
+	
+	@Override protected String getDirName() {
+		return "studio";
+	}
+	
+	@Override protected String getMacExecutableName() {
+		return "jbdevstudio.app";
+	}
+	
+	@Override protected String getUnixExecutableName() {
+		return "jbdevstudio";
+	}
+	
+	@Override protected String getWindowsExecutableName() {
+		return "jbdevstudio.exe";
+	}
+	
+	@Override protected List<String> getSourceDirsOnWindows() {
+		return Arrays.asList("\\", "\\Program Files", "\\Program Files (x86)", System.getProperty("user.home", "."));
+	}
+	
+	@Override protected List<String> getSourceDirsOnMac() {
+		return Arrays.asList("/Applications", System.getProperty("user.home", "."));
+	}
+	
+	@Override protected List<String> getSourceDirsOnUnix() {
+		return Arrays.asList(System.getProperty("user.home", "."));
+	}
+}
diff --git a/src/installer/lombok/installer/eclipse/JbdsLocation.java b/src/installer/lombok/installer/eclipse/JbdsLocation.java
new file mode 100644
index 00000000..81fb5261
--- /dev/null
+++ b/src/installer/lombok/installer/eclipse/JbdsLocation.java
@@ -0,0 +1,45 @@
+/*
+ * Copyright (C) 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.installer.eclipse;
+
+import java.io.File;
+import java.net.URL;
+
+import lombok.installer.CorruptedIdeLocationException;
+
+public class JbdsLocation extends EclipseLocation {
+	public JbdsLocation(String nameOfLocation, File pathToEclipseIni) throws CorruptedIdeLocationException {
+		super(nameOfLocation, pathToEclipseIni);
+	}
+	
+	@Override public URL getIdeIcon() {
+		return JbdsLocation.class.getResource("jbds.png");
+	}
+	
+	@Override protected String getIniFileName() {
+		return "jbdevstudio.ini";
+	}
+	
+	@Override protected String getTypeName() {
+		return "JBoss Developer Studio";
+	}
+}
diff --git a/src/installer/lombok/installer/eclipse/JbdsLocationProvider.java b/src/installer/lombok/installer/eclipse/JbdsLocationProvider.java
new file mode 100644
index 00000000..e6df0e43
--- /dev/null
+++ b/src/installer/lombok/installer/eclipse/JbdsLocationProvider.java
@@ -0,0 +1,69 @@
+/*
+ * Copyright (C) 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.installer.eclipse;
+
+import java.io.File;
+import java.util.Arrays;
+import java.util.List;
+import java.util.regex.Pattern;
+
+import lombok.installer.CorruptedIdeLocationException;
+import lombok.installer.IdeLocation;
+import lombok.installer.IdeLocationProvider;
+import lombok.installer.IdeFinder.OS;
+
+import org.mangosdk.spi.ProviderFor;
+
+@ProviderFor(IdeLocationProvider.class)
+public class JbdsLocationProvider extends EclipseLocationProvider {
+	@Override protected List<String> getEclipseExecutableNames() {
+		return Arrays.asList("jbdevstudio.app", "jbdevstudio.exe", "jbdevstudioc.exe", "jbdevstudio");
+	}
+	
+	@Override protected String getIniName() {
+		return "jbdevstudio.ini";
+	}
+	
+	@Override protected IdeLocation makeLocation(String name, File ini) throws CorruptedIdeLocationException {
+		return new JbdsLocation(name, ini);
+	}
+	
+	@Override protected String getMacAppName() {
+		return "jbdevstudio.app";
+	}
+	
+	@Override protected String getUnixAppName() {
+		return "jbdevstudio";
+	}
+	
+	@Override public Pattern getLocationSelectors(OS os) {
+		switch (os) {
+		case MAC_OS_X:
+			return Pattern.compile("^(jbdevstudio|jbdevstudio\\.ini|jbdevstudio\\.app)$", Pattern.CASE_INSENSITIVE);
+		case WINDOWS:
+			return Pattern.compile("^(jbdevstudioc?\\.exe|jbdevstudio\\.ini)$", Pattern.CASE_INSENSITIVE);
+		default:
+		case UNIX:
+			return Pattern.compile("^(jbdevstudio|jbdevstudio\\.ini)$", Pattern.CASE_INSENSITIVE);
+		}
+	}
+}
diff --git a/src/installer/lombok/installer/eclipse/STSFinder.java b/src/installer/lombok/installer/eclipse/STSFinder.java
index 74b8ed34..82bc9b80 100644
--- a/src/installer/lombok/installer/eclipse/STSFinder.java
+++ b/src/installer/lombok/installer/eclipse/STSFinder.java
@@ -57,7 +57,7 @@ public class STSFinder extends EclipseFinder {
 	}
 	
 	@Override protected List<String> getSourceDirsOnWindows() {
-		return Arrays.asList("\\", "\\springsource", "\\Program Files", "\\Program Files\\springsource", System.getProperty("user.home", "."), System.getProperty("user.home", ".") + "\\springsource");
+		return Arrays.asList("\\", "\\springsource", "\\Program Files", "\\Program Files (x86)", "\\Program Files\\springsource", "\\Program Files (x86)\\springsource", System.getProperty("user.home", "."), System.getProperty("user.home", ".") + "\\springsource");
 	}
 	
 	@Override protected List<String> getSourceDirsOnMac() {
diff --git a/src/installer/lombok/installer/eclipse/jbds.png b/src/installer/lombok/installer/eclipse/jbds.png
new file mode 100644
index 00000000..ca7738e6
--- /dev/null
+++ b/src/installer/lombok/installer/eclipse/jbds.png
diff --git a/test/core/src/lombok/AbstractRunTests.java b/test/core/src/lombok/AbstractRunTests.java
index a3f52cdd..d278c5f3 100644
--- a/test/core/src/lombok/AbstractRunTests.java
+++ b/test/core/src/lombok/AbstractRunTests.java
@@ -72,7 +72,7 @@ public abstract class AbstractRunTests {
 		StringReader r = new StringReader(expectedFile);
 		BufferedReader br = new BufferedReader(r);
 		String firstLine = br.readLine();
-		if (firstLine != null && firstLine.startsWith("//ignore")) return false;
+		if (firstLine != null && (firstLine.startsWith("//ignore") || params.shouldIgnoreBasedOnVersion(firstLine))) return false;
 		
 		compare(
 				file.getName(),
diff --git a/test/core/src/lombok/DirectoryRunner.java b/test/core/src/lombok/DirectoryRunner.java
index 191a7b63..a3b4de00 100644
--- a/test/core/src/lombok/DirectoryRunner.java
+++ b/test/core/src/lombok/DirectoryRunner.java
@@ -29,15 +29,43 @@ import java.io.FileReader;
 import java.io.IOException;
 import java.util.Map;
 import java.util.TreeMap;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
 
 import org.junit.runner.Description;
 import org.junit.runner.Runner;
 import org.junit.runner.notification.Failure;
 import org.junit.runner.notification.RunNotifier;
 
+import com.sun.tools.javac.main.JavaCompiler;
+
 public class DirectoryRunner extends Runner {
 	public enum Compiler {
-		DELOMBOK, JAVAC, ECJ;
+		DELOMBOK {
+			@Override public int getVersion() {
+				Matcher m = VERSION_PARSER.matcher(JavaCompiler.version());
+				if (m.matches()) {
+					int major = Integer.parseInt(m.group(1));
+					int minor = Integer.parseInt(m.group(2));
+					if (major == 1) return minor;
+				}
+				
+				return 6;
+			}
+		}, 
+		JAVAC {
+			@Override public int getVersion() {
+				return DELOMBOK.getVersion();
+			}
+		},
+		ECJ {
+			@Override public int getVersion() {
+				return 6;
+			}
+		};
+		
+		private static final Pattern VERSION_PARSER = Pattern.compile("^(\\d+)\\.(\\d+).*$");
+		public abstract int getVersion();
 	}
 	
 	public static abstract class TestParams {
@@ -46,10 +74,52 @@ public class DirectoryRunner extends Runner {
 		public abstract File getBeforeDirectory();
 		public abstract File getAfterDirectory();
 		public abstract File getMessagesDirectory();
+		/** Version of the JDK dialect that the compiler can understand; for example, if you return '7', you should know what try-with-resources is. */
+		public int getVersion() {
+			return getCompiler().getVersion();
+		}
 		
 		public boolean accept(File file) {
 			return true;
 		}
+		
+		private static final Pattern P1 = Pattern.compile("^(\\d+)$");
+		private static final Pattern P2 = Pattern.compile("^\\:(\\d+)$");
+		private static final Pattern P3 = Pattern.compile("^(\\d+):$");
+		private static final Pattern P4 = Pattern.compile("^(\\d+):(\\d+)$");
+		
+		public boolean shouldIgnoreBasedOnVersion(String firstLine) {
+			int thisVersion = getVersion();
+			if (!firstLine.startsWith("//version ")) return false;
+			
+			String spec = firstLine.substring("//version ".length());
+			
+			/* Single version: '5' */ {
+				Matcher m = P1.matcher(spec);
+				if (m.matches()) return Integer.parseInt(m.group(1)) != thisVersion;
+			}
+			
+			/* Upper bound: ':5' (inclusive) */ {
+				Matcher m = P2.matcher(spec);
+				if (m.matches()) return Integer.parseInt(m.group(1)) < thisVersion;
+			}
+			
+			/* Lower bound '5:' (inclusive) */ {
+				Matcher m = P3.matcher(spec);
+				if (m.matches()) return Integer.parseInt(m.group(1)) > thisVersion;
+			}
+			
+			/* Range '7:8' (inclusive) */ {
+				Matcher m = P4.matcher(spec);
+				if (m.matches()) {
+					if (Integer.parseInt(m.group(1)) < thisVersion) return true;
+					if (Integer.parseInt(m.group(2)) > thisVersion) return true;
+					return false;
+				}
+			}
+			
+			throw new IllegalArgumentException("Version validity spec not valid: " + spec);
+		}
 	}
 	
 	private static final FileFilter JAVA_FILE_FILTER = new FileFilter() {
@@ -135,6 +205,6 @@ public class DirectoryRunner extends Runner {
 		BufferedReader reader = new BufferedReader(new FileReader(file));
 		String line = reader.readLine();
 		reader.close();
-		return line != null && line.startsWith("//ignore");
+		return line != null && (line.startsWith("//ignore") || params.shouldIgnoreBasedOnVersion(line));
 	}
 }
diff --git a/test/core/src/lombok/RunTestsViaEcj.java b/test/core/src/lombok/RunTestsViaEcj.java
index 0bf97213..ca443620 100644
--- a/test/core/src/lombok/RunTestsViaEcj.java
+++ b/test/core/src/lombok/RunTestsViaEcj.java
@@ -129,10 +129,11 @@ public class RunTestsViaEcj extends AbstractRunTests {
 			}
 		}
 		classpath.add("dist/lombok.jar");
-		classpath.add("lib/test/commons-logging.jar");
-		classpath.add("lib/test/slf4j-api.jar");
-		classpath.add("lib/test/slf4j-ext.jar");
-		classpath.add("lib/test/log4j.jar");
+		classpath.add("lib/test/commons-logging-commons-logging.jar");
+		classpath.add("lib/test/org.slf4j-slf4j-api.jar");
+		classpath.add("lib/test/org.slf4j-slf4j-ext.jar");
+		classpath.add("lib/test/log4j-log4j.jar");
+		classpath.add("lib/test/org.apache.logging.log4j-log4j-api.jar");
 		return new FileSystem(classpath.toArray(new String[0]), new String[] {file.getAbsolutePath()}, "UTF-8");
 	}
 }
diff --git a/test/pretty/resource/after/TryWithResources.java b/test/pretty/resource/after/TryWithResources.java
new file mode 100644
index 00000000..1a8b82e2
--- /dev/null
+++ b/test/pretty/resource/after/TryWithResources.java
@@ -0,0 +1,9 @@
+//version 7:
+import java.io.PrintWriter;
+public class TryWithResources {
+	{
+		try (final PrintWriter pw = new PrintWriter(System.out);) {
+			pw.println();
+		}
+	}
+}
diff --git a/test/pretty/resource/before/TryWithResources.java b/test/pretty/resource/before/TryWithResources.java
new file mode 100644
index 00000000..eb622f2c
--- /dev/null
+++ b/test/pretty/resource/before/TryWithResources.java
@@ -0,0 +1,9 @@
+//version 7:
+import java.io.PrintWriter;
+public class TryWithResources {
+	{
+		try (PrintWriter pw = new PrintWriter(System.out)) {
+			pw.println();
+		}
+	}
+}
diff --git a/test/transform/resource/after-delombok/LoggerCommons.java b/test/transform/resource/after-delombok/LoggerCommons.java
index c2a03815..dfe3e88d 100644
--- a/test/transform/resource/after-delombok/LoggerCommons.java
+++ b/test/transform/resource/after-delombok/LoggerCommons.java
@@ -1,7 +1,6 @@
 class LoggerCommons {
 	private static final org.apache.commons.logging.Log log = org.apache.commons.logging.LogFactory.getLog(LoggerCommons.class);
 }
-
 class LoggerCommonsWithImport {
 	private static final org.apache.commons.logging.Log log = org.apache.commons.logging.LogFactory.getLog(LoggerCommonsWithImport.class);
 }
\ No newline at end of file
diff --git a/test/transform/resource/after-delombok/LoggerJul.java b/test/transform/resource/after-delombok/LoggerJul.java
index 39cb2aac..b020c540 100644
--- a/test/transform/resource/after-delombok/LoggerJul.java
+++ b/test/transform/resource/after-delombok/LoggerJul.java
@@ -1,7 +1,6 @@
 class LoggerJul {
 	private static final java.util.logging.Logger log = java.util.logging.Logger.getLogger(LoggerJul.class.getName());
 }
-
 class LoggerJulWithImport {
 	private static final java.util.logging.Logger log = java.util.logging.Logger.getLogger(LoggerJulWithImport.class.getName());
 }
\ No newline at end of file
diff --git a/test/transform/resource/after-delombok/LoggerLog4j.java b/test/transform/resource/after-delombok/LoggerLog4j.java
index 6892a7d8..dfbad89a 100644
--- a/test/transform/resource/after-delombok/LoggerLog4j.java
+++ b/test/transform/resource/after-delombok/LoggerLog4j.java
@@ -1,7 +1,6 @@
 class LoggerLog4j {
 	private static final org.apache.log4j.Logger log = org.apache.log4j.Logger.getLogger(LoggerLog4j.class);
 }
-
 class LoggerLog4jWithImport {
 	private static final org.apache.log4j.Logger log = org.apache.log4j.Logger.getLogger(LoggerLog4jWithImport.class);
 }
\ No newline at end of file
diff --git a/test/transform/resource/after-delombok/LoggerLog4j2.java b/test/transform/resource/after-delombok/LoggerLog4j2.java
new file mode 100644
index 00000000..3447a9a5
--- /dev/null
+++ b/test/transform/resource/after-delombok/LoggerLog4j2.java
@@ -0,0 +1,6 @@
+class LoggerLog4j2 {
+	private static final org.apache.logging.log4j.Logger log = org.apache.logging.log4j.LogManager.getLogger(LoggerLog4j2.class);
+}
+class LoggerLog4j2WithImport {
+	private static final org.apache.logging.log4j.Logger log = org.apache.logging.log4j.LogManager.getLogger(LoggerLog4j2WithImport.class);
+}
\ No newline at end of file
diff --git a/test/transform/resource/after-delombok/LoggerSlf4j.java b/test/transform/resource/after-delombok/LoggerSlf4j.java
index cb1486ba..4cc7c107 100644
--- a/test/transform/resource/after-delombok/LoggerSlf4j.java
+++ b/test/transform/resource/after-delombok/LoggerSlf4j.java
@@ -1,11 +1,9 @@
 class LoggerSlf4j {
 	private static final org.slf4j.Logger log = org.slf4j.LoggerFactory.getLogger(LoggerSlf4j.class);
 }
-
 class LoggerSlf4jWithImport {
 	private static final org.slf4j.Logger log = org.slf4j.LoggerFactory.getLogger(LoggerSlf4jWithImport.class);
 }
-
 class LoggerSlf4jOuter {
 	static class Inner {
 		private static final org.slf4j.Logger log = org.slf4j.LoggerFactory.getLogger(Inner.class);
diff --git a/test/transform/resource/after-delombok/LoggerXSlf4j.java b/test/transform/resource/after-delombok/LoggerXSlf4j.java
index 0239c60b..7d8f3236 100644
--- a/test/transform/resource/after-delombok/LoggerXSlf4j.java
+++ b/test/transform/resource/after-delombok/LoggerXSlf4j.java
@@ -1,7 +1,6 @@
 class LoggerXSlf4j {
 	private static final org.slf4j.ext.XLogger log = org.slf4j.ext.XLoggerFactory.getXLogger(LoggerXSlf4j.class);
 }
-
 class LoggerXSlf4jWithImport {
 	private static final org.slf4j.ext.XLogger log = org.slf4j.ext.XLoggerFactory.getXLogger(LoggerXSlf4jWithImport.class);
 }
\ No newline at end of file
diff --git a/test/transform/resource/after-ecj/LoggerLog4j2.java b/test/transform/resource/after-ecj/LoggerLog4j2.java
new file mode 100644
index 00000000..c1368e5d
--- /dev/null
+++ b/test/transform/resource/after-ecj/LoggerLog4j2.java
@@ -0,0 +1,17 @@
+import lombok.extern.log4j.Log4j2;
+@lombok.extern.log4j.Log4j2 class LoggerLog4j2 {
+  private static final org.apache.logging.log4j.Logger log = org.apache.logging.log4j.LogManager.getLogger(LoggerLog4j2.class);
+  <clinit>() {
+  }
+  LoggerLog4j2() {
+    super();
+  }
+}
+@Log4j2 class LoggerLog4j2WithImport {
+  private static final org.apache.logging.log4j.Logger log = org.apache.logging.log4j.LogManager.getLogger(LoggerLog4j2WithImport.class);
+  <clinit>() {
+  }
+  LoggerLog4j2WithImport() {
+    super();
+  }
+}
\ No newline at end of file
diff --git a/test/transform/resource/before/LoggerLog4j2.java b/test/transform/resource/before/LoggerLog4j2.java
new file mode 100644
index 00000000..b7ea99ee
--- /dev/null
+++ b/test/transform/resource/before/LoggerLog4j2.java
@@ -0,0 +1,9 @@
+import lombok.extern.log4j.Log4j2;
+
+@lombok.extern.log4j.Log4j2
+class LoggerLog4j2 {
+}
+
+@Log4j2
+class LoggerLog4j2WithImport {
+}
\ No newline at end of file
diff --git a/website/download.html b/website/download.html
index bb354c8f..dea43799 100644
--- a/website/download.html
+++ b/website/download.html
@@ -44,7 +44,7 @@
 			<div class="edgeLink">Feeling adventurous? Download the latest <a href="download-edge.html">snapshot</a> release.</div>
 			
 			<table cellspacing="0" cellpadding="0">
-				<tr><td class="platform">Maven or Ivy</td>
+				<tr><td class="platform">Maven&nbsp;or&nbsp;Ivy</td>
 				<td class="instruction">Lombok is in maven central. <a href="mavenrepo/index.html">More&hellip;</a></td></tr>
 				
 				<tr><td class="platform">Javac</td>
@@ -53,10 +53,10 @@
 				<tr><td class="platform">NetBeans</td>
 				<td class="instruction">Just put <code>lombok.jar</code> on the classpath and enable annotation processing. <a href="setup/netbeans.html">More&hellip;</a></td></tr>
 				
-				<tr><td class="platform">Eclipse and STS</td>
-				<td class="instruction">Run <code>lombok.jar</code> as a java app (i.e. doubleclick it, usually) to install. Also add lombok.jar to your project.</td></tr>
+				<tr><td class="platform">Eclipse&nbsp;and&nbsp;variants</td>
+				<td class="instruction">Run <code>lombok.jar</code> as a java app (i.e. doubleclick it, usually) to install. Also add lombok.jar to your project. <span style="font-size: 0.8em;"><em>Supported variants: Springsource Tool Suite, JBoss Developer Studio</em></span></td></tr>
 				
-				<tr><td class="platform">IDEA IntelliJ</td>
+				<tr><td class="platform">IDEA&nbsp;IntelliJ</td>
 				<td class="instruction">lombok doesn't (yet) work under IntelliJ. We're working on it though!</td></tr>
 				
 				<tr><td class="platform">Javadoc</td>
@@ -68,7 +68,7 @@
 				<tr><td class="platform">GWT</td>
 				<td class="instruction">Lombok works with GWT. <a href="setup/gwt.html">More&hellip;</a></td></tr>
 				
-				<tr><td class="platform">Play! Framework</td>
+				<tr><td class="platform">Play!&nbsp;Framework</td>
 				<td class="instruction">Use Aaron Freeman's <a href="https://github.com/aaronfreeman/play-lombok#readme">lombok play plugin</a>.</td></tr>
 				
 				<tr><td class="platform">ecj</td>
diff --git a/website/features/Log.html b/website/features/Log.html
index fb529426..2fb91956 100644
--- a/website/features/Log.html
+++ b/website/features/Log.html
@@ -16,9 +16,9 @@
 			<h3>Overview</h3>
 			<p>
 			<em>NEW in lombok 0.10: </em>You can annotate any class with a log annotation to let lombok generate a logger field.<br />
-			The logger is named <code>log</code> and field's type depends on which logger you have selected.
+			The logger is named <code>log</code> and the field's type depends on which logger you have selected.
 			</p><p>
-			There are four choices available:<br />
+			There are six choices available:<br />
 			<dl>
 				<dt><code>@CommonsLog</code></dt>
 				<dd>Creates <code><span class="keyword">private&nbsp;static&nbsp;final&nbsp;</span><a href="http://commons.apache.org/logging/apidocs/org/apache/commons/logging/Log.html">org.apache.commons.logging.Log</a>&nbsp;<span class="staticfield">log</span>&nbsp;=&nbsp;<a href="http://commons.apache.org/logging/apidocs/org/apache/commons/logging/LogFactory.html#getLog(java.lang.Class)">org.apache.commons.logging.LogFactory.getLog</a>(LogExample.<span class="keyword">class</span>);</code></dd>
@@ -26,6 +26,8 @@
 				<dd>Creates <code><span class="keyword">private&nbsp;static&nbsp;final&nbsp;</span><a href="http://download.oracle.com/javase/6/docs/api/java/util/logging/Logger.html">java.util.logging.Logger</a>&nbsp;<span class="staticfield">log</span>&nbsp;=&nbsp;<a href="http://download.oracle.com/javase/6/docs/api/java/util/logging/Logger.html#getLogger(java.lang.String)">java.util.logging.Logger.getLogger</a>(LogExample.<span class="keyword">class</span>.getName());</code></dd>
 				<dt><code>@Log4j</code></dt>
 				<dd>Creates <code><span class="keyword">private&nbsp;static&nbsp;final&nbsp;</span><a href="http://logging.apache.org/log4j/1.2/apidocs/org/apache/log4j/Logger.html">org.apache.log4j.Logger</a>&nbsp;<span class="staticfield">log</span>&nbsp;=&nbsp;<a href="http://logging.apache.org/log4j/1.2/apidocs/org/apache/log4j/Logger.html#getLogger(java.lang.Class)">org.apache.log4j.Logger.getLogger</a>(LogExample.<span class="keyword">class</span>);</code></dd>
+				<dt><code>@Log4j2</code></dt>
+				<dd>Creates <code><span class="keyword">private&nbsp;static&nbsp;final&nbsp;</span><a href="http://logging.apache.org/log4j/2.0/log4j-api/apidocs/org/apache/logging/log4j/Logger.html">org.apache.logging.log4j.Logger</a>&nbsp;<span class="staticfield">log</span>&nbsp;=&nbsp;<a href="http://logging.apache.org/log4j/2.0/log4j-api/apidocs/org/apache/logging/log4j/LogManager.html#getLogger(java.lang.Class)">org.apache.logging.log4j.LogManager.getLogger</a>(LogExample.<span class="keyword">class</span>);</code></dd>
 				<dt><code>@Slf4j</code></dt>
 				<dd>Creates <code><span class="keyword">private&nbsp;static&nbsp;final&nbsp;</span><a href="http://www.slf4j.org/api/org/slf4j/Logger.html">org.slf4j.Logger</a>&nbsp;<span class="staticfield">log</span>&nbsp;=&nbsp;<a href="http://www.slf4j.org/apidocs/org/slf4j/LoggerFactory.html#getLogger(java.lang.Class)">org.slf4j.LoggerFactory.getLogger</a>(LogExample.<span class="keyword">class</span>);</code></dd>
 				<dt><code>@XSlf4j</code></dt>
diff --git a/website/features/SneakyThrows.html b/website/features/SneakyThrows.html
index 0f04b7d9..808a7879 100644
--- a/website/features/SneakyThrows.html
+++ b/website/features/SneakyThrows.html
@@ -64,7 +64,11 @@
 				statement in a try/catch block with just <code>e.printStackTrace()</code> in the catch block. This is so spectacularly non-productive
 				compared to just sneakily throwing the exception onwards, that Roel and Reinier feel more than justified in claiming that the
 				checked exception system is far from perfect, and thus an opt-out mechanism is warranted.
-				</p>
+				</p><p>
+				If you put <code>@SneakyThrows</code> on a constructor, any call to a sibling or super constructor is <em>excluded</em> from the <code>@SneakyThrows</code> treatment. This is a
+				java restriction we cannot work around: Calls to sibling/super constructors MUST be the first statement in the constructor; they cannot be placed inside try/catch blocks.
+				</p><p>
+				<code>@SneakyThrows</code> on an empty method, or a constructor that is empty or only has a call to a sibling / super constructor results in no try/catch block and a warning.
 			</div>
 		</div>
 		<div class="footer">