Merge branch 'master' of git@github.com:rzwitserloot/lombok

src/core/lombok/eclipse/handlers/HandleData.java

@@ -21,13 +21,21 @@
  */
 package lombok.eclipse.handlers;
 
-import static lombok.eclipse.Eclipse.*;
-import static lombok.eclipse.handlers.EclipseHandlerUtil.*;
+import static lombok.eclipse.Eclipse.copyAnnotations;
+import static lombok.eclipse.Eclipse.copyType;
+import static lombok.eclipse.Eclipse.copyTypeParams;
+import static lombok.eclipse.handlers.EclipseHandlerUtil.constructorExists;
+import static lombok.eclipse.handlers.EclipseHandlerUtil.findAnnotations;
+import static lombok.eclipse.handlers.EclipseHandlerUtil.generateNullCheck;
+import static lombok.eclipse.handlers.EclipseHandlerUtil.injectMethod;
+import static lombok.eclipse.handlers.EclipseHandlerUtil.methodExists;
 
 import java.lang.reflect.Modifier;
 import java.util.ArrayList;
 import java.util.Collection;
+import java.util.LinkedHashMap;
 import java.util.List;
+import java.util.Map;
 
 import lombok.AccessLevel;
 import lombok.Data;
@@ -84,6 +92,7 @@ public class HandleData implements EclipseAnnotationHandler<Data> {
 		}
 		
 		List<EclipseNode> nodesForConstructor = new ArrayList<EclipseNode>();
+		Map<EclipseNode, Boolean> gettersAndSetters = new LinkedHashMap<EclipseNode, Boolean>();
 		for (EclipseNode child : typeNode.down()) {
 			if (child.getKind() != Kind.FIELD) continue;
 			FieldDeclaration fieldDecl = (FieldDeclaration) child.get();
@@ -94,13 +103,9 @@ public class HandleData implements EclipseAnnotationHandler<Data> {
 			boolean isFinal = (fieldDecl.modifiers & ClassFileConstants.AccFinal) != 0;
 			boolean isNonNull = findAnnotations(fieldDecl, TransformationsUtil.NON_NULL_PATTERN).length != 0;
 			if ((isFinal || isNonNull) && fieldDecl.initialization == null) nodesForConstructor.add(child);
-			new HandleGetter().generateGetterForField(child, annotationNode.get());
-			if (!isFinal) new HandleSetter().generateSetterForField(child, annotationNode.get());
+			gettersAndSetters.put(child, !isFinal);
 		}
 		
-		new HandleToString().generateToStringForType(typeNode, annotationNode);
-		new HandleEqualsAndHashCode().generateEqualsAndHashCodeForType(typeNode, annotationNode);
-		
 		//Careful: Generate the public static constructor (if there is one) LAST, so that any attempt to
 		//'find callers' on the annotation node will find callers of the constructor, which is by far the
 		//most useful of the many methods built by @Data. This trick won't work for the non-static constructor,
@@ -121,6 +126,14 @@ public class HandleData implements EclipseAnnotationHandler<Data> {
 			}
 		}
 		
+		for (Map.Entry<EclipseNode, Boolean> field : gettersAndSetters.entrySet()) {
+			new HandleGetter().generateGetterForField(field.getKey(), annotationNode.get());
+			if (field.getValue()) new HandleSetter().generateSetterForField(field.getKey(), annotationNode.get());
+		}
+		
+		new HandleEqualsAndHashCode().generateEqualsAndHashCodeForType(typeNode, annotationNode);
+		new HandleToString().generateToStringForType(typeNode, annotationNode);
+				
 		return false;
 	}
 	

src/core/lombok/eclipse/handlers/HandleEqualsAndHashCode.java

@@ -204,21 +204,6 @@ public class HandleEqualsAndHashCode implements EclipseAnnotationHandler<EqualsA
 			}
 		}
 		
-		switch (methodExists("hashCode", typeNode)) {
-		case NOT_EXISTS:
-			MethodDeclaration hashCode = createHashCode(typeNode, nodesForEquality, callSuper, errorNode.get());
-			injectMethod(typeNode, hashCode);
-			break;
-		case EXISTS_BY_LOMBOK:
-			break;
-		default:
-		case EXISTS_BY_USER:
-			if (whineIfExists) {
-				errorNode.addWarning("Not generating hashCode(): A method with that name already exists");
-			}
-			break;
-		}
-		
 		switch (methodExists("equals", typeNode)) {
 		case NOT_EXISTS:
 			MethodDeclaration equals = createEquals(typeNode, nodesForEquality, callSuper, errorNode.get());
@@ -234,6 +219,21 @@ public class HandleEqualsAndHashCode implements EclipseAnnotationHandler<EqualsA
 			break;
 		}
 		
+		switch (methodExists("hashCode", typeNode)) {
+		case NOT_EXISTS:
+			MethodDeclaration hashCode = createHashCode(typeNode, nodesForEquality, callSuper, errorNode.get());
+			injectMethod(typeNode, hashCode);
+			break;
+		case EXISTS_BY_LOMBOK:
+			break;
+		default:
+		case EXISTS_BY_USER:
+			if (whineIfExists) {
+				errorNode.addWarning("Not generating hashCode(): A method with that name already exists");
+			}
+			break;
+		}
+		
 		return true;
 	}
 	

src/core/lombok/javac/HandlerLibrary.java

@@ -165,7 +165,6 @@ public class HandlerLibrary {
 			if (container == null) continue;
 			
 			try {
-				System.out.println("Calling handle on: "+ container.handler.getClass().getName());
 				handled |= container.handle(node);
 			} catch (AnnotationValueDecodeFail fail) {
 				fail.owner.setError(fail.getMessage(), fail.idx);

src/core/lombok/javac/handlers/HandleData.java

@@ -21,9 +21,16 @@
  */
 package lombok.javac.handlers;
 
-import static lombok.javac.handlers.JavacHandlerUtil.*;
+import static lombok.javac.handlers.JavacHandlerUtil.constructorExists;
+import static lombok.javac.handlers.JavacHandlerUtil.findAnnotations;
+import static lombok.javac.handlers.JavacHandlerUtil.generateNullCheck;
+import static lombok.javac.handlers.JavacHandlerUtil.injectMethod;
+import static lombok.javac.handlers.JavacHandlerUtil.markAnnotationAsProcessed;
+import static lombok.javac.handlers.JavacHandlerUtil.methodExists;
 
 import java.lang.reflect.Modifier;
+import java.util.LinkedHashMap;
+import java.util.Map;
 
 import lombok.Data;
 import lombok.core.AnnotationValues;
@@ -72,6 +79,7 @@ public class HandleData implements JavacAnnotationHandler<Data> {
 		}
 		
 		List<JavacNode> nodesForConstructor = List.nil();
+		Map<JavacNode, Boolean> gettersAndSetters = new LinkedHashMap<JavacNode, Boolean>();
 		for (JavacNode child : typeNode.down()) {
 			if (child.getKind() != Kind.FIELD) continue;
 			JCVariableDecl fieldDecl = (JCVariableDecl) child.get();
@@ -83,13 +91,9 @@ public class HandleData implements JavacAnnotationHandler<Data> {
 			boolean isFinal = (fieldFlags & Flags.FINAL) != 0;
 			boolean isNonNull = !findAnnotations(child, TransformationsUtil.NON_NULL_PATTERN).isEmpty();
 			if ((isFinal || isNonNull) && fieldDecl.init == null) nodesForConstructor = nodesForConstructor.append(child);
-			new HandleGetter().generateGetterForField(child, annotationNode.get());
-			if (!isFinal) new HandleSetter().generateSetterForField(child, annotationNode.get());
+			gettersAndSetters.put(child, !isFinal);
 		}
 		
-		new HandleToString().generateToStringForType(typeNode, annotationNode);
-		new HandleEqualsAndHashCode().generateEqualsAndHashCodeForType(typeNode, annotationNode);
-		
 		String staticConstructorName = annotation.getInstance().staticConstructor();
 		
 		if (constructorExists(typeNode) == MemberExistsResult.NOT_EXISTS) {
@@ -102,6 +106,14 @@ public class HandleData implements JavacAnnotationHandler<Data> {
 			injectMethod(typeNode, staticConstructor);
 		}
 		
+		for (Map.Entry<JavacNode, Boolean> field : gettersAndSetters.entrySet()) {
+			new HandleGetter().generateGetterForField(field.getKey(), annotationNode.get());
+			if (field.getValue()) new HandleSetter().generateSetterForField(field.getKey(), annotationNode.get());
+		}
+		
+		new HandleEqualsAndHashCode().generateEqualsAndHashCodeForType(typeNode, annotationNode);
+		new HandleToString().generateToStringForType(typeNode, annotationNode);
+		
 		return true;
 	}
 	

src/core/lombok/javac/handlers/HandleEqualsAndHashCode.java

@@ -167,21 +167,6 @@ public class HandleEqualsAndHashCode implements JavacAnnotationHandler<EqualsAnd
 			}
 		}
 		
-		switch (methodExists("hashCode", typeNode)) {
-		case NOT_EXISTS:
-			JCMethodDecl method = createHashCode(typeNode, nodesForEquality, callSuper);
-			injectMethod(typeNode, method);
-			break;
-		case EXISTS_BY_LOMBOK:
-			break;
-		default:
-		case EXISTS_BY_USER:
-			if (whineIfExists) {
-				errorNode.addWarning("Not generating hashCode(): A method with that name already exists");
-			}
-			break;
-		}
-		
 		switch (methodExists("equals", typeNode)) {
 		case NOT_EXISTS:
 			JCMethodDecl method = createEquals(typeNode, nodesForEquality, callSuper);
@@ -197,6 +182,21 @@ public class HandleEqualsAndHashCode implements JavacAnnotationHandler<EqualsAnd
 			break;
 		}
 		
+		switch (methodExists("hashCode", typeNode)) {
+		case NOT_EXISTS:
+			JCMethodDecl method = createHashCode(typeNode, nodesForEquality, callSuper);
+			injectMethod(typeNode, method);
+			break;
+		case EXISTS_BY_LOMBOK:
+			break;
+		default:
+		case EXISTS_BY_USER:
+			if (whineIfExists) {
+				errorNode.addWarning("Not generating hashCode(): A method with that name already exists");
+			}
+			break;
+		}
+		
 		return true;
 	}
 	
@@ -326,7 +326,7 @@ public class HandleEqualsAndHashCode implements JavacAnnotationHandler<EqualsAnd
 		
 		JCAnnotation overrideAnnotation = maker.Annotation(chainDots(maker, typeNode, "java", "lang", "Override"), List.<JCExpression>nil());
 		JCModifiers mods = maker.Modifiers(Flags.PUBLIC, List.of(overrideAnnotation));
-		JCExpression objectType = maker.Type(typeNode.getSymbolTable().objectType);
+		JCExpression objectType = chainDots(maker, typeNode, "java", "lang", "Object");
 		JCExpression returnType = maker.TypeIdent(TypeTags.BOOLEAN);
 		
 		List<JCStatement> statements = List.nil();

src/core/lombok/javac/handlers/HandleSneakyThrows.java

@@ -26,6 +26,7 @@ import static lombok.javac.handlers.JavacHandlerUtil.markAnnotationAsProcessed;
 
 import java.util.ArrayList;
 import java.util.Collection;
+import java.util.Collections;
 
 import lombok.SneakyThrows;
 import lombok.core.AnnotationValues;
@@ -52,9 +53,9 @@ public class HandleSneakyThrows implements JavacAnnotationHandler<SneakyThrows>
 	@Override public boolean handle(AnnotationValues<SneakyThrows> annotation, JCAnnotation ast, JavacNode annotationNode) {
 		markAnnotationAsProcessed(annotationNode, SneakyThrows.class);
 		Collection<String> exceptionNames = annotation.getRawExpressions("value");
-		
-		List<JCExpression> memberValuePairs = ast.getArguments();
-		if (memberValuePairs == null || memberValuePairs.size() == 0) return false;
+		if (exceptionNames.isEmpty()) {
+			exceptionNames = Collections.singleton("java.lang.Throwable");
+		}
 		
 		java.util.List<String> exceptions = new ArrayList<String>();
 		for (String exception : exceptionNames) {

src/delombok/lombok/delombok/DelombokApp.java

@@ -108,7 +108,7 @@ public class DelombokApp implements LombokApp {
 				}
 			};
 			try {
-				loader.loadClass("lombok.delombok.Delombok").getMethod("main", String[].class).invoke(null, new Object[] {args});
+				loader.loadClass("lombok.delombok.Delombok").getMethod("main", String[].class).invoke(null, new Object[] {args.toArray(new String[0])});
 			} catch (InvocationTargetException e1) {
 				Throwable t = e1.getCause();
 				if (t instanceof Error) throw (Error)t;

test/delombok/resource/after/CleanupName.java

@@ -1,5 +1,5 @@
-class Cleanup {
-	void test() throws Exception {
+class CleanupName {
+	void test() {
 		Object o = "Hello World!";
 		try {
 			System.out.println(o);
@@ -7,4 +7,12 @@ class Cleanup {
 			o.toString();
 		}
 	}
+	void test2() {
+		Object o = "Hello World too!";
+		try {
+			System.out.println(o);
+		} finally {
+			o.toString();
+		}
+	}
 }

test/delombok/resource/after/DataPlain.java

@@ -0,0 +1,76 @@
+class Data1 {
+	final int x;
+	String name;
+	public Data1(final int x) {
+		this.x = x;
+	}
+	public int getX() {
+		return x;
+	}
+	public String getName() {
+		return name;
+	}
+	public void setName(final String name) {
+		this.name = name;
+	}
+	@java.lang.Override
+	public boolean equals(final java.lang.Object o) {
+		if (o == this) return true;
+		if (o == null) return false;
+		if (o.getClass() != this.getClass()) return false;
+		final Data1 other = (Data1)o;
+		if (this.x != other.x) return false;
+		if (this.name == null ? other.name != null : !this.name.equals(other.name)) return false;
+		return true;
+	}
+	@java.lang.Override
+	public int hashCode() {
+		final int PRIME = 31;
+		int result = 1;
+		result = result * PRIME + this.x;
+		result = result * PRIME + (this.name == null ? 0 : this.name.hashCode());
+		return result;
+	}
+	@java.lang.Override
+	public java.lang.String toString() {
+		return "Data1(x=" + x + ", name=" + name + ")";
+	}
+}
+class Data2 {
+	final int x;
+	String name;
+	public Data2(final int x) {
+		this.x = x;
+	}
+	public int getX() {
+		return x;
+	}
+	public String getName() {
+		return name;
+	}
+	public void setName(final String name) {
+		this.name = name;
+	}
+	@java.lang.Override
+	public boolean equals(final java.lang.Object o) {
+		if (o == this) return true;
+		if (o == null) return false;
+		if (o.getClass() != this.getClass()) return false;
+		final Data2 other = (Data2)o;
+		if (this.x != other.x) return false;
+		if (this.name == null ? other.name != null : !this.name.equals(other.name)) return false;
+		return true;
+	}
+	@java.lang.Override
+	public int hashCode() {
+		final int PRIME = 31;
+		int result = 1;
+		result = result * PRIME + this.x;
+		result = result * PRIME + (this.name == null ? 0 : this.name.hashCode());
+		return result;
+	}
+	@java.lang.Override
+	public java.lang.String toString() {
+		return "Data2(x=" + x + ", name=" + name + ")";
+	}
+}

test/delombok/resource/after/GetterAccessLevel.java

@@ -1,9 +1,15 @@
-class Getter {
+class GetterAccessLevel {
 	boolean isNone;
 	boolean isPrivate;
 	boolean isPackage;
 	boolean isProtected;
 	boolean isPublic;
+	String noneString;
+	String privateString;
+	String packageString;
+	String protectedString;
+	String publicString;
+	String value;
 	private boolean isPrivate() {
 		return isPrivate;
 	}
@@ -16,4 +22,19 @@ class Getter {
 	public boolean isPublic() {
 		return isPublic;
 	}
-}
+	private String getPrivateString() {
+		return privateString;
+	}
+	String getPackageString() {
+		return packageString;
+	}
+	protected String getProtectedString() {
+		return protectedString;
+	}
+	public String getPublicString() {
+		return publicString;
+	}
+	public String getValue() {
+		return value;
+	}
+}

test/delombok/resource/after/SetterAccessLevel.java

@@ -1,9 +1,10 @@
-class Setter {
+class SetterAccessLevel {
 	boolean isNone;
 	boolean isPrivate;
 	boolean isPackage;
 	boolean isProtected;
 	boolean isPublic;
+	boolean value;
 	private void setIsPrivate(final boolean isPrivate) {
 		this.isPrivate = isPrivate;
 	}
@@ -16,4 +17,7 @@ class Setter {
 	public void setIsPublic(final boolean isPublic) {
 		this.isPublic = isPublic;
 	}
+	public void setValue(final boolean value) {
+		this.value = value;
+	}
 }

test/delombok/resource/after/SneakyThrowsMultiple.java

@@ -0,0 +1,45 @@
+import java.awt.AWTException;
+import java.io.IOException;
+import java.util.Random;
+class SneakyThrowsMultiple {
+	public void test() {
+		try {
+			try {
+				System.out.println("test1");
+				throw new IOException();
+			} catch (IOException $ex) {
+				throw lombok.Lombok.sneakyThrow($ex);
+			}
+		} catch (Throwable $ex) {
+			throw lombok.Lombok.sneakyThrow($ex);
+		}
+	}
+	public void test2() {
+		try {
+			try {
+				System.out.println("test2");
+				if (new Random().nextBoolean()) {
+					throw new IOException();
+				} else {
+					throw new AWTException("WHAT");
+				}
+			} catch (AWTException $ex) {
+				throw lombok.Lombok.sneakyThrow($ex);
+			}
+		} catch (IOException $ex) {
+			throw lombok.Lombok.sneakyThrow($ex);
+		}
+	}
+	public void test3() {
+		try {
+			try {
+				System.out.println("test3");
+				throw new IOException();
+			} catch (IOException $ex) {
+				throw lombok.Lombok.sneakyThrow($ex);
+			}
+		} catch (Throwable $ex) {
+			throw lombok.Lombok.sneakyThrow($ex);
+		}
+	}
+}

test/delombok/resource/after/SneakyThrowsPlain.java

@@ -0,0 +1,17 @@
+class SneakyThrowsPlain {
+	public void test() {
+		try {
+			System.out.println("test1");
+		} catch (java.lang.Throwable $ex) {
+			throw lombok.Lombok.sneakyThrow($ex);
+		}
+	}
+	
+	public void test2() {
+		try {
+			System.out.println("test2");
+		} catch (java.lang.Throwable $ex) {
+			throw lombok.Lombok.sneakyThrow($ex);
+		}
+	}
+}

test/delombok/resource/after/SneakyThrowsSingle.java

@@ -0,0 +1,26 @@
+import java.io.IOException;
+class SneakyThrowsSingle {
+	public void test() {
+		try {
+			System.out.println("test1");
+		} catch (Throwable $ex) {
+			throw lombok.Lombok.sneakyThrow($ex);
+		}
+	}
+	public void test2() {
+		try {
+			System.out.println("test2");
+			throw new IOException();
+		} catch (IOException $ex) {
+			throw lombok.Lombok.sneakyThrow($ex);
+		}
+	}
+	public void test3() {
+		try {
+			System.out.println("test3");
+			throw new IOException();
+		} catch (IOException $ex) {
+			throw lombok.Lombok.sneakyThrow($ex);
+		}
+	}
+}

test/delombok/resource/after/SynchronizedName.java

@@ -17,4 +17,9 @@ class SynchronizedName {
 			System.out.println("four");
 		}
 	}
+	void test5() {
+		synchronized (read) {
+			System.out.println("five");
+		}
+	}
 }

test/delombok/resource/before/CleanupName.java

@@ -1,6 +1,10 @@
-class Cleanup {
-	void test() throws Exception {
+class CleanupName {
+	void test() {
 		@lombok.Cleanup("toString") Object o = "Hello World!";
 		System.out.println(o);
 	}
+	void test2() {
+		@lombok.Cleanup(value="toString") Object o = "Hello World too!";
+		System.out.println(o);
+	}
 }

test/delombok/resource/before/DataPlain.java

@@ -0,0 +1,9 @@
+import lombok.Data;
+@lombok.Data class Data1 {
+	final int x;
+	String name;
+}
+@Data class Data2 {
+	final int x;
+	String name;
+}

test/delombok/resource/before/GetterAccessLevel.java

@@ -1,4 +1,4 @@
-class Getter {
+class GetterAccessLevel {
 	@lombok.Getter(lombok.AccessLevel.NONE)
 	boolean isNone;
 	@lombok.Getter(lombok.AccessLevel.PRIVATE)
@@ -9,4 +9,16 @@ class Getter {
 	boolean isProtected;
 	@lombok.Getter(lombok.AccessLevel.PUBLIC)
 	boolean isPublic;
+	@lombok.Getter(lombok.AccessLevel.NONE)
+	String noneString;
+	@lombok.Getter(lombok.AccessLevel.PRIVATE)
+	String privateString;
+	@lombok.Getter(lombok.AccessLevel.PACKAGE)
+	String packageString;
+	@lombok.Getter(lombok.AccessLevel.PROTECTED)
+	String protectedString;
+	@lombok.Getter(lombok.AccessLevel.PUBLIC)
+	String publicString;
+	@lombok.Getter(value=lombok.AccessLevel.PUBLIC)
+	String value;
 }

test/delombok/resource/before/SetterAccessLevel.java

@@ -1,4 +1,4 @@
-class Setter {
+class SetterAccessLevel {
 	@lombok.Setter(lombok.AccessLevel.NONE)
 	boolean isNone;
 	@lombok.Setter(lombok.AccessLevel.PRIVATE)
@@ -9,4 +9,6 @@ class Setter {
 	boolean isProtected;
 	@lombok.Setter(lombok.AccessLevel.PUBLIC)
 	boolean isPublic;
+	@lombok.Setter(value=lombok.AccessLevel.PUBLIC)
+	boolean value;
 }

test/delombok/resource/before/SneakyThrowsMultiple.java

@@ -0,0 +1,28 @@
+import java.awt.AWTException;
+import java.io.IOException;
+import java.util.Random;
+
+class SneakyThrowsMultiple {
+	@lombok.SneakyThrows(IOException.class,Throwable.class) 
+	public void test() {
+		System.out.println("test1");
+		throw new IOException();
+	}
+	
+	@lombok.SneakyThrows(AWTException.class,IOException.class)
+	public void test2() {
+		System.out.println("test2");
+		if (new Random().nextBoolean()) {
+			throw new IOException();
+		}
+		else {
+			throw new AWTException("WHAT");
+		}
+	}
+	
+	@lombok.SneakyThrows(value={IOException.class,Throwable.class})
+	public void test3() {
+		System.out.println("test3");
+		throw new IOException();
+	}
+}

test/delombok/resource/before/SneakyThrowsPlain.java

@@ -0,0 +1,10 @@
+import lombok.SneakyThrows;
+class SneakyThrowsPlain {
+	@lombok.SneakyThrows public void test() {
+		System.out.println("test1");
+	}
+	
+	@SneakyThrows public void test2() {
+		System.out.println("test2");
+	}
+}

test/delombok/resource/before/SneakyThrowsSingle.java

@@ -0,0 +1,21 @@
+import java.io.IOException;
+
+class SneakyThrowsSingle {
+	@lombok.SneakyThrows(Throwable.class) 
+	public void test() {
+		System.out.println("test1");
+	}
+	
+	@lombok.SneakyThrows(IOException.class)
+	public void test2() {
+		System.out.println("test2");
+		throw new IOException();
+	}
+	
+	@lombok.SneakyThrows(value=IOException.class)
+	public void test3() {
+		System.out.println("test3");
+		throw new IOException();
+	}
+
+}

test/delombok/resource/before/SynchronizedName.java

@@ -15,4 +15,7 @@ class SynchronizedName {
 	@lombok.Synchronized("READ") void test4() {
 		System.out.println("four");
 	}	
+	@lombok.Synchronized(value="read") void test5() {
+		System.out.println("five");
+	}
 }