Added initial support for the @Data annotation. Currently produces getters and setters only,

not yet a constructor, toString, hashCode, or equals.

HandleGetter and HandleSetter have been updated to handle static (theoretic; you can't put annotations on static fields normally).

You can now make AnnotationValue objects using just an annotationNode and a target type, as well as check if a given annotationNode is likely to represent a target annotation type. This is in Javac and Eclipse classes.

HandleGetter and HandleSetter can now be asked to make a getter/setter, and will grab access level off of a Getter/Setter annotation, if present.

1 files changed, 41 insertions, 9 deletions

diff --git a/src/lombok/eclipse/handlers/HandleGetter.java b/src/lombok/eclipse/handlers/HandleGetter.java
index ca561a48..798705da 100644
--- a/src/lombok/eclipse/handlers/HandleGetter.java
+++ b/src/lombok/eclipse/handlers/HandleGetter.java
@@ -2,9 +2,12 @@ package lombok.eclipse.handlers;
 
 import static lombok.eclipse.handlers.PKG.*;
 
+import lombok.AccessLevel;
 import lombok.Getter;
 import lombok.core.AnnotationValues;
 import lombok.core.TransformationsUtil;
+import lombok.core.AST.Kind;
+import lombok.eclipse.Eclipse;
 import lombok.eclipse.EclipseAnnotationHandler;
 import lombok.eclipse.EclipseAST.Node;
 
@@ -19,30 +22,59 @@ import org.eclipse.jdt.internal.compiler.ast.SingleNameReference;
 import org.eclipse.jdt.internal.compiler.ast.Statement;
 import org.eclipse.jdt.internal.compiler.ast.TypeDeclaration;
 import org.eclipse.jdt.internal.compiler.ast.TypeReference;
+import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;
 import org.eclipse.jdt.internal.compiler.lookup.MethodScope;
 import org.mangosdk.spi.ProviderFor;
 
 @ProviderFor(EclipseAnnotationHandler.class)
 public class HandleGetter implements EclipseAnnotationHandler<Getter> {
+	public void generateGetterForField(Node fieldNode, ASTNode pos) {
+		AccessLevel level = Getter.DEFAULT_ACCESS_LEVEL;
+		Node errorNode = fieldNode;
+		
+		for ( Node child : fieldNode.down() ) {
+			if ( child.getKind() == Kind.ANNOTATION ) {
+				if ( Eclipse.annotationTypeMatches(Getter.class, child) ) {
+					level = Eclipse.createAnnotation(Getter.class, child).getInstance().value();
+					errorNode = child;
+					pos = child.get();
+					break;
+				}
+			}
+		}
+		
+		createGetterForField(level, fieldNode, errorNode, pos);
+	}
+	
 	@Override public boolean handle(AnnotationValues<Getter> annotation, Annotation ast, Node annotationNode) {
-		if ( !(annotationNode.up().get() instanceof FieldDeclaration) ) return false;
-		FieldDeclaration field = (FieldDeclaration) annotationNode.up().get();
+		Node fieldNode = annotationNode.up();
+		AccessLevel level = annotation.getInstance().value();
+		return createGetterForField(level, fieldNode, annotationNode, annotationNode.get());
+	}
+	
+	private boolean createGetterForField(AccessLevel level, Node fieldNode, Node errorNode, ASTNode pos) {
+		if ( fieldNode.getKind() != Kind.FIELD ) {
+			errorNode.addError("@Getter is only supported on a field.");
+			return false;
+		}
+		
+		FieldDeclaration field = (FieldDeclaration) fieldNode.get();
 		TypeReference fieldType = field.type;
 		String getterName = TransformationsUtil.toGetterName(
 				new String(field.name), nameEquals(fieldType.getTypeName(), "boolean"));
 		
-		TypeDeclaration parent = (TypeDeclaration) annotationNode.up().up().get();
+		TypeDeclaration parent = (TypeDeclaration) fieldNode.up().get();
 		if ( parent.methods != null ) for ( AbstractMethodDeclaration method : parent.methods ) {
 			if ( method.selector != null && new String(method.selector).equals(getterName) ) {
-				annotationNode.addWarning(String.format(
+				errorNode.addWarning(String.format(
 						"Not generating %s(): A method with that name already exists",  getterName));
 				return false;
 			}
 		}
 		
-		int modifier = toModifier(annotation.getInstance().value());
+		int modifier = toModifier(level) | (field.modifiers & ClassFileConstants.AccStatic);
 		
-		MethodDeclaration method = generateGetter(parent, field, getterName, modifier, ast);
+		MethodDeclaration method = generateGetter(parent, field, getterName, modifier, pos);
 		
 		if ( parent.methods == null ) {
 			parent.methods = new AbstractMethodDeclaration[1];
@@ -58,7 +90,7 @@ public class HandleGetter implements EclipseAnnotationHandler<Getter> {
 	}
 	
 	private MethodDeclaration generateGetter(TypeDeclaration parent, FieldDeclaration field, String name,
-			int modifier, Annotation ast) {
+			int modifier, ASTNode pos) {
 		MethodDeclaration method = new MethodDeclaration(parent.compilationResult);
 		method.modifiers = modifier;
 		method.returnType = field.type;
@@ -72,8 +104,8 @@ public class HandleGetter implements EclipseAnnotationHandler<Getter> {
 		method.bits |= ASTNode.Bit24;
 		Expression fieldExpression = new SingleNameReference(field.name, (field.declarationSourceStart << 32) | field.declarationSourceEnd);
 		Statement returnStatement = new ReturnStatement(fieldExpression, field.sourceStart, field.sourceEnd);
-		method.bodyStart = method.declarationSourceStart = method.sourceStart = ast.sourceStart;
-		method.bodyEnd = method.declarationSourceEnd = method.sourceEnd = ast.sourceEnd;
+		method.bodyStart = method.declarationSourceStart = method.sourceStart = pos.sourceStart;
+		method.bodyEnd = method.declarationSourceEnd = method.sourceEnd = pos.sourceEnd;
 		method.statements = new Statement[] { returnStatement };
 		return method;
 	}