Merge branch 'master' into jdk8. Also added some major fixes whilst merging.

Conflicts:
	src/core/lombok/javac/handlers/JavacHandlerUtil.java
	src/utils/lombok/javac/CommentCatcher.java
	src/utils/lombok/javac/Javac.java

69 files changed, 2750 insertions, 545 deletions

diff --git a/src/core/lombok/Data.java b/src/core/lombok/Data.java
index ee6f2fcb..bbc8d920 100644
--- a/src/core/lombok/Data.java
+++ b/src/core/lombok/Data.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2009-2012 The Project Lombok Authors.
+ * Copyright (C) 2009-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
@@ -39,7 +39,7 @@ import java.lang.annotation.Target;
  * @see RequiredArgsConstructor
  * @see ToString
  * @see EqualsAndHashCode
- * @see lombok.experimental.Value
+ * @see lombok.Value
  */
 @Target(ElementType.TYPE)
 @Retention(RetentionPolicy.SOURCE)
diff --git a/src/core/lombok/NonNull.java b/src/core/lombok/NonNull.java
index 5f5d8ed2..96813170 100644
--- a/src/core/lombok/NonNull.java
+++ b/src/core/lombok/NonNull.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2009 The Project Lombok Authors.
+ * Copyright (C) 2009-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
@@ -28,12 +28,14 @@ import java.lang.annotation.RetentionPolicy;
 import java.lang.annotation.Target;
 
 /**
- * Lombok is smart enough to translate any annotation named {@code @NonNull} in any casing and
- * with any package name to the return type of generated getters and the parameter of generated setters and constructors,
- * as well as generate the appropriate null checks in the setter and constructor.
- * 
- * You can use this annotation for the purpose, though you can also use JSR305's annotation, findbugs's, pmd's, or IDEA's, or just
- * about anyone elses. As long as it is named {@code @NonNull}.
+ * If put on a parameter, lombok will insert a null-check at the start of the method / constructor's body, throwing a
+ * {@code NullPointerException} with the parameter's name as message. If put on a field, any generated method assigning
+ * a value to this field will also produce these nullchecks.
+ * <p>
+ * Note that any annotation named {@code NonNull} with any casing and any package will result in nullchecks produced for
+ * generated methods (and the annotation will be copied to the getter return type and any parameters of generated methods),
+ * but <em>only</em> this annotation, if present on a parameter, will result in a null check inserted into your otherwise
+ * handwritten method.
  * 
  * WARNING: If the java community ever does decide on supporting a single {@code @NonNull} annotation (for example via JSR305), then
  * this annotation will <strong>be deleted</strong> from the lombok package. If the need to update an import statement scares
diff --git a/src/core/lombok/Value.java b/src/core/lombok/Value.java
new file mode 100644
index 00000000..2cffe15b
--- /dev/null
+++ b/src/core/lombok/Value.java
@@ -0,0 +1,58 @@
+/*
+ * 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
+ * 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;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Generates a lot of code which fits with a class that is a representation of an immutable entity.
+ * <p>
+ * Equivalent to {@code @Getter @FieldDefaults(makeFinal=true, level=AccessLevel.PRIVATE) @RequiredArgsConstructor @ToString @EqualsAndHashCode}.
+ * <p>
+ * Complete documentation is found at <a href="http://projectlombok.org/features/experimental/Value.html">the project lombok features page for &#64;Value</a>.
+ * 
+ * @see lombok.Getter
+ * @see lombok.experimental.FieldDefaults
+ * @see lombok.RequiredArgsConstructor
+ * @see lombok.ToString
+ * @see lombok.EqualsAndHashCode
+ * @see lombok.Data
+ */
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.SOURCE)
+public @interface Value {
+	/**
+	 * If you specify a static constructor name, then the generated constructor will be private, and
+	 * instead a static factory method is created that other classes can use to create instances.
+	 * We suggest the name: "of", like so:
+	 * 
+	 * <pre>
+	 *     public @Data(staticConstructor = "of") class Point { final int x, y; }
+	 * </pre>
+	 * 
+	 * Default: No static constructor, instead the normal constructor is public.
+	 */
+	String staticConstructor() default "";
+}
diff --git a/src/core/lombok/bytecode/PreventNullAnalysisRemover.java b/src/core/lombok/bytecode/PreventNullAnalysisRemover.java
index a3f18b40..751e691f 100644
--- a/src/core/lombok/bytecode/PreventNullAnalysisRemover.java
+++ b/src/core/lombok/bytecode/PreventNullAnalysisRemover.java
@@ -44,12 +44,12 @@ public class PreventNullAnalysisRemover implements PostCompilerTransformation {
 		byte[] fixedByteCode = fixJSRInlining(original);
 		
 		ClassReader reader = new ClassReader(fixedByteCode);
-		ClassWriter writer = new FixedClassWriter(reader, ClassWriter.COMPUTE_MAXS | ClassWriter.COMPUTE_FRAMES);
+		ClassWriter writer = new FixedClassWriter(reader, 0);
 		
 		final AtomicBoolean changesMade = new AtomicBoolean();
 		
-		class PreventNullanalysisVisitor extends MethodVisitor {
-			PreventNullanalysisVisitor(MethodVisitor mv) {
+		class PreventNullAnalysisVisitor extends MethodVisitor {
+			PreventNullAnalysisVisitor(MethodVisitor mv) {
 				super(Opcodes.ASM4, mv);
 			}
 			
@@ -61,6 +61,7 @@ public class PreventNullAnalysisRemover implements PostCompilerTransformation {
 				if (hit && !"(Ljava/lang/Object;)Ljava/lang/Object;".equals(desc)) hit = false;
 				if (hit) {
 					changesMade.set(true);
+					if (System.getProperty("lombok.debugAsmOnly", null) != null) super.visitMethodInsn(opcode, owner, name, desc); // DEBUG for issue 470!
 				} else {
 					super.visitMethodInsn(opcode, owner, name, desc);
 				}
@@ -69,7 +70,7 @@ public class PreventNullAnalysisRemover implements PostCompilerTransformation {
 		
 		reader.accept(new ClassVisitor(Opcodes.ASM4, writer) {
 			@Override public MethodVisitor visitMethod(int access, String name, String desc, String signature, String[] exceptions) {
-				return new PreventNullanalysisVisitor(super.visitMethod(access, name, desc, signature, exceptions));
+				return new PreventNullAnalysisVisitor(super.visitMethod(access, name, desc, signature, exceptions));
 			}
 		}, 0);
 		return changesMade.get() ? writer.toByteArray() : null;
diff --git a/src/core/lombok/bytecode/SneakyThrowsRemover.java b/src/core/lombok/bytecode/SneakyThrowsRemover.java
index 8143d860..914c313a 100644
--- a/src/core/lombok/bytecode/SneakyThrowsRemover.java
+++ b/src/core/lombok/bytecode/SneakyThrowsRemover.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
@@ -32,19 +32,21 @@ import org.mangosdk.spi.ProviderFor;
 import org.objectweb.asm.ClassReader;
 import org.objectweb.asm.ClassVisitor;
 import org.objectweb.asm.ClassWriter;
+import org.objectweb.asm.Handle;
+import org.objectweb.asm.Label;
 import org.objectweb.asm.MethodVisitor;
 import org.objectweb.asm.Opcodes;
 
 @ProviderFor(PostCompilerTransformation.class)
 public class SneakyThrowsRemover implements PostCompilerTransformation {
 	
-	@Override public byte[] applyTransformations(byte[] original, String fileName, DiagnosticsReceiver diagnostics) {
+	@Override public byte[] applyTransformations(byte[] original, String fileName, final DiagnosticsReceiver diagnostics) {
 		if (!new ClassFileMetaData(original).usesMethod("lombok/Lombok", "sneakyThrow")) return null;
 		
 		byte[] fixedByteCode = fixJSRInlining(original);
 		
 		ClassReader reader = new ClassReader(fixedByteCode);
-		ClassWriter writer = new FixedClassWriter(reader, ClassWriter.COMPUTE_MAXS | ClassWriter.COMPUTE_FRAMES);
+		ClassWriter writer = new ClassWriter(reader, 0);
 		
 		final AtomicBoolean changesMade = new AtomicBoolean();
 		
@@ -53,6 +55,8 @@ public class SneakyThrowsRemover implements PostCompilerTransformation {
 				super(Opcodes.ASM4, mv);
 			}
 			
+			private boolean methodInsnQueued = false;
+			
 			@Override public void visitMethodInsn(int opcode, String owner, String name, String desc) {
 				if (
 						opcode == Opcodes.INVOKESTATIC &&
@@ -60,12 +64,117 @@ public class SneakyThrowsRemover implements PostCompilerTransformation {
 						"lombok/Lombok".equals(owner) &&
 						"(Ljava/lang/Throwable;)Ljava/lang/RuntimeException;".equals(desc)) {
 					
-					changesMade.set(true);
-					super.visitInsn(Opcodes.ATHROW);
+					if (System.getProperty("lombok.debugAsmOnly", null) != null) {
+						super.visitMethodInsn(opcode, owner, name, desc); // DEBUG for issue 470!
+					} else {
+						methodInsnQueued = true;
+					}
 				} else {
 					super.visitMethodInsn(opcode, owner, name, desc);
 				}
 			}
+			
+			private void handleQueue() {
+				if (!methodInsnQueued) return;
+				super.visitMethodInsn(Opcodes.INVOKESTATIC, "lombok/Lombok", "sneakyThrow", "(Ljava/lang/Throwable;)Ljava/lang/RuntimeException;");
+				methodInsnQueued = false;
+				diagnostics.addWarning("Proper usage is: throw lombok.Lombok.sneakyThrow(someException);. You did not 'throw' it. Because of this, the call to sneakyThrow " +
+						"remains in your classfile and you will need lombok.jar on the classpath at runtime.");
+			}
+			
+			@Override public void visitInsn(int arg0) {
+				if (methodInsnQueued && arg0 == Opcodes.ATHROW) {
+					changesMade.set(true);
+					// As expected, the required ATHROW. We can now safely 'eat' the previous call.
+					methodInsnQueued = false;
+				}
+				handleQueue();
+				super.visitInsn(arg0);
+			}
+			@Override public void visitFrame(int arg0, int arg1, Object[] arg2, int arg3, Object[] arg4) {
+				handleQueue();
+				super.visitFrame(arg0, arg1, arg2, arg3, arg4);
+			}
+			
+			@Override public void visitIincInsn(int arg0, int arg1) {
+				handleQueue();
+				super.visitIincInsn(arg0, arg1);
+			}
+			
+			@Override public void visitFieldInsn(int arg0, String arg1, String arg2, String arg3) {
+				handleQueue();
+				super.visitFieldInsn(arg0, arg1, arg2, arg3);
+			}
+			
+			@Override public void visitIntInsn(int arg0, int arg1) {
+				handleQueue();
+				super.visitIntInsn(arg0, arg1);
+			}
+			
+			@Override public void visitEnd() {
+				handleQueue();
+				super.visitEnd();
+			}
+			
+			@Override public void visitInvokeDynamicInsn(String arg0, String arg1, Handle arg2, Object... arg3) {
+				handleQueue();
+				super.visitInvokeDynamicInsn(arg0, arg1, arg2, arg3);
+			}
+			
+			@Override public void visitLabel(Label arg0) {
+				handleQueue();
+				super.visitLabel(arg0);
+			}
+			
+			@Override public void visitJumpInsn(int arg0, Label arg1) {
+				handleQueue();
+				super.visitJumpInsn(arg0, arg1);
+			}
+			
+			@Override public void visitLdcInsn(Object arg0) {
+				handleQueue();
+				super.visitLdcInsn(arg0);
+			}
+			
+			@Override public void visitLocalVariable(String arg0, String arg1, String arg2, Label arg3, Label arg4, int arg5) {
+				handleQueue();
+				super.visitLocalVariable(arg0, arg1, arg2, arg3, arg4, arg5);
+			}
+			
+			@Override public void visitMaxs(int arg0, int arg1) {
+				handleQueue();
+				super.visitMaxs(arg0, arg1);
+			}
+			
+			@Override public void visitLookupSwitchInsn(Label arg0, int[] arg1, Label[] arg2) {
+				handleQueue();
+				super.visitLookupSwitchInsn(arg0, arg1, arg2);
+			}
+			
+			@Override public void visitMultiANewArrayInsn(String arg0, int arg1) {
+				handleQueue();
+				super.visitMultiANewArrayInsn(arg0, arg1);
+			}
+			
+			@Override public void visitVarInsn(int arg0, int arg1) {
+				handleQueue();
+				super.visitVarInsn(arg0, arg1);
+			}
+			
+			@Override public void visitTryCatchBlock(Label arg0, Label arg1, Label arg2, String arg3) {
+				handleQueue();
+				super.visitTryCatchBlock(arg0, arg1, arg2, arg3);
+			}
+			
+			@Override public void visitTableSwitchInsn(int arg0, int arg1, Label arg2, Label... arg3) {
+				handleQueue();
+				super.visitTableSwitchInsn(arg0, arg1, arg2, arg3);
+			}
+			
+			@Override public void visitTypeInsn(int arg0, String arg1) {
+				handleQueue();
+				super.visitTypeInsn(arg0, arg1);
+			}
 		}
 		
 		reader.accept(new ClassVisitor(Opcodes.ASM4, writer) {
diff --git a/src/core/lombok/core/AST.java b/src/core/lombok/core/AST.java
index 68f36412..6fed0252 100644
--- a/src/core/lombok/core/AST.java
+++ b/src/core/lombok/core/AST.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2009 The Project Lombok Authors.
+ * Copyright (C) 2009-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
@@ -30,7 +30,6 @@ import java.lang.reflect.ParameterizedType;
 import java.lang.reflect.Type;
 import java.util.ArrayList;
 import java.util.Collection;
-import java.util.Collections;
 import java.util.HashMap;
 import java.util.IdentityHashMap;
 import java.util.List;
@@ -54,15 +53,15 @@ public abstract class AST<A extends AST<A, L, N>, L extends LombokNode<A, L, N>,
 	private L top;
 	private final String fileName;
 	private final String packageDeclaration;
-	private final Collection<String> imports;
-	Map<N, Void> identityDetector = new IdentityHashMap<N, Void>();
+	private final ImportList imports;
+	Map<N, N> identityDetector = new IdentityHashMap<N, N>();
 	private Map<N, L> nodeMap = new IdentityHashMap<N, L>();
 	private boolean changed = false;
 	
-	protected AST(String fileName, String packageDeclaration, Collection<String> imports) {
+	protected AST(String fileName, String packageDeclaration, ImportList imports) {
 		this.fileName = fileName == null ? "(unknown).java" : fileName;
 		this.packageDeclaration = packageDeclaration;
-		this.imports = Collections.unmodifiableCollection(new ArrayList<String>(imports));
+		this.imports = imports;
 	}
 	
 	public void setChanged() {
@@ -96,7 +95,7 @@ public abstract class AST<A extends AST<A, L, N>, L extends LombokNode<A, L, N>,
 	 * 
 	 * Example: "java.util.IOException".
 	 */
-	public final Collection<String> getImportStatements() {
+	public final ImportList getImportList() {
 		return imports;
 	}
 	
@@ -106,7 +105,7 @@ public abstract class AST<A extends AST<A, L, N>, L extends LombokNode<A, L, N>,
 	 */
 	protected L putInMap(L node) {
 		nodeMap.put(node.get(), node);
-		identityDetector.put(node.get(), null);
+		identityDetector.put(node.get(), node.get());
 		return node;
 	}
 	
@@ -118,7 +117,7 @@ public abstract class AST<A extends AST<A, L, N>, L extends LombokNode<A, L, N>,
 	/** Clears the registry that avoids endless loops, and empties the node map. The existing node map
 	 * object is left untouched, and instead a new map is created. */
 	protected void clearState() {
-		identityDetector = new IdentityHashMap<N, Void>();
+		identityDetector = new IdentityHashMap<N, N>();
 		nodeMap = new IdentityHashMap<N, L>();
 	}
 	
@@ -128,9 +127,7 @@ public abstract class AST<A extends AST<A, L, N>, L extends LombokNode<A, L, N>,
 	 * case you should do nothing lest the AST build process loops endlessly.
 	 */
 	protected boolean setAndGetAsHandled(N node) {
-		if (identityDetector.containsKey(node)) return true;
-		identityDetector.put(node, null);
-		return false;
+		return identityDetector.put(node, node) != null;
 	}
 	
 	public String getFileName() {
@@ -147,6 +144,24 @@ public abstract class AST<A extends AST<A, L, N>, L extends LombokNode<A, L, N>,
 		return nodeMa