Use the actual annotation value to process the @Log annotations instead of their String representations.

6 files changed, 67 insertions, 71 deletions

diff --git a/src/core/lombok/eclipse/handlers/HandleLog.java b/src/core/lombok/eclipse/handlers/HandleLog.java
index ad0ad200..736e6e43 100644
--- a/src/core/lombok/eclipse/handlers/HandleLog.java
+++ b/src/core/lombok/eclipse/handlers/HandleLog.java
@@ -28,7 +28,6 @@ import java.lang.reflect.Modifier;
 import java.util.Arrays;
 
 import lombok.core.AnnotationValues;
-import lombok.core.AST.Kind;
 import lombok.eclipse.Eclipse;
 import lombok.eclipse.EclipseAnnotationHandler;
 import lombok.eclipse.EclipseNode;
@@ -42,6 +41,7 @@ import org.eclipse.jdt.internal.compiler.ast.MessageSend;
 import org.eclipse.jdt.internal.compiler.ast.NameReference;
 import org.eclipse.jdt.internal.compiler.ast.QualifiedNameReference;
 import org.eclipse.jdt.internal.compiler.ast.QualifiedTypeReference;
+import org.eclipse.jdt.internal.compiler.ast.SingleTypeReference;
 import org.eclipse.jdt.internal.compiler.ast.TypeDeclaration;
 import org.eclipse.jdt.internal.compiler.ast.TypeReference;
 import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;
@@ -54,10 +54,11 @@ public class HandleLog {
 	}
 	
 	public static boolean processAnnotation(LoggingFramework framework, AnnotationValues<? extends java.lang.annotation.Annotation> annotation, Annotation source, EclipseNode annotationNode) {
-		
-		String loggingClassName = annotation.getRawExpression("value");
-		if (loggingClassName == null) loggingClassName = "void";
-		if (loggingClassName.endsWith(".class")) loggingClassName = loggingClassName.substring(0, loggingClassName.length() - 6);
+		Expression annotationValue = (Expression) annotation.getActualExpression("value");
+		if (annotationValue != null && !(annotationValue instanceof ClassLiteralAccess)) {
+			return true;
+		}
+		ClassLiteralAccess loggingType = (ClassLiteralAccess)annotationValue;
 		
 		EclipseNode owner = annotationNode.up();
 		switch (owner.getKind()) {
@@ -79,11 +80,11 @@ public class HandleLog {
 				return true;
 			}
 			
-			if (loggingClassName.equals("void")) {
-				loggingClassName = getSelfName(owner);
+			if (loggingType == null) {
+				loggingType = selfType(owner, source);
 			}
 			
-			injectField(owner, createField(framework, source, loggingClassName));
+			injectField(owner, createField(framework, source, loggingType));
 			owner.rebuild();
 			return true;
 		default:
@@ -92,27 +93,21 @@ public class HandleLog {
 		}
 	}
 	
-	private static String getSelfName(EclipseNode type) {
-		String typeName = getSingleTypeName(type);
-		EclipseNode upType = type.up();
-		while (upType.getKind() == Kind.TYPE) {
-			typeName = getSingleTypeName(upType) + "." + typeName;
-			upType = upType.up();
-		}
-		String packageDeclaration = type.getPackageDeclaration();
-		if (packageDeclaration != null) {
-			typeName = packageDeclaration + "." + typeName;
-		}
-		return typeName;
-	}
-	
-	private static String getSingleTypeName(EclipseNode type) {
+	private static ClassLiteralAccess selfType(EclipseNode type, Annotation source) {
+		int pS = source.sourceStart, pE = source.sourceEnd;
+		long p = (long)pS << 32 | pE;
+
 		TypeDeclaration typeDeclaration = (TypeDeclaration)type.get();
-		char[] rawTypeName = typeDeclaration.name;
-		return rawTypeName == null ? "" : new String(rawTypeName);
+		TypeReference typeReference = new SingleTypeReference(typeDeclaration.name, p);
+		Eclipse.setGeneratedBy(typeReference, source);
+
+		ClassLiteralAccess result = new ClassLiteralAccess(source.sourceEnd, typeReference);
+		Eclipse.setGeneratedBy(result, source);
+		
+		return result;
 	}
 	
-	private static FieldDeclaration createField(LoggingFramework framework, Annotation source, String loggingClassName) {
+	private static FieldDeclaration createField(LoggingFramework framework, Annotation source, ClassLiteralAccess loggingType) {
 		int pS = source.sourceStart, pE = source.sourceEnd;
 		long p = (long)pS << 32 | pE;
 		
@@ -131,7 +126,7 @@ public class HandleLog {
 		factoryMethodCall.receiver = createNameReference(framework.getLoggerFactoryTypeName(), source);
 		factoryMethodCall.selector = framework.getLoggerFactoryMethodName().toCharArray();
 		
-		Expression parameter = framework.createFactoryParameter(loggingClassName, source);
+		Expression parameter = framework.createFactoryParameter(loggingType, source);
 		
 		factoryMethodCall.arguments = new Expression[] { parameter };
 		factoryMethodCall.nameSourcePosition = p;
@@ -147,11 +142,19 @@ public class HandleLog {
 		int pS = source.sourceStart, pE = source.sourceEnd;
 		long p = (long)pS << 32 | pE;
 		
-		char[][] typeNameTokens = fromQualifiedName(typeName);
-		long[] pos = new long[typeNameTokens.length];
-		Arrays.fill(pos, p);
+		TypeReference typeReference;
+		if (typeName.contains(".")) {
+			
+			char[][] typeNameTokens = fromQualifiedName(typeName);
+			long[] pos = new long[typeNameTokens.length];
+			Arrays.fill(pos, p);
+			
+			typeReference = new QualifiedTypeReference(typeNameTokens, pos);
+		}
+		else {
+			typeReference = null;
+		}
 		
-		QualifiedTypeReference typeReference = new QualifiedTypeReference(typeNameTokens, pos);
 		Eclipse.setGeneratedBy(typeReference, source);
 		return typeReference;
 	}
@@ -217,14 +220,14 @@ public class HandleLog {
 		
 		// private static final java.util.logging.Logger log = java.util.logging.Logger.getLogger(TargetType.class.getName());
 		JUL(lombok.extern.jul.Log.class, "java.util.logging.Logger", "java.util.logging.Logger", "getLogger") {
-			@Override public Expression createFactoryParameter(String typeName, Annotation source) {
+			@Override public Expression createFactoryParameter(ClassLiteralAccess type, Annotation source) {
 				int pS = source.sourceStart, pE = source.sourceEnd;
 				long p = (long)pS << 32 | pE;
 				
 				MessageSend factoryParameterCall = new MessageSend();
 				Eclipse.setGeneratedBy(factoryParameterCall, source);
 				
-				factoryParameterCall.receiver = super.createFactoryParameter(typeName, source);
+				factoryParameterCall.receiver = super.createFactoryParameter(type, source);
 				factoryParameterCall.selector = "getName".toCharArray();
 				
 				factoryParameterCall.nameSourcePosition = p;
@@ -271,9 +274,9 @@ public class HandleLog {
 			return loggerFactoryMethodName;
 		}
 		
-		Expression createFactoryParameter(String typeName, Annotation source){
-			TypeReference type = createTypeReference(typeName, source);
-			ClassLiteralAccess result = new ClassLiteralAccess(source.sourceEnd, type);
+		Expression createFactoryParameter(ClassLiteralAccess loggingType, Annotation source){
+			TypeReference copy = Eclipse.copyType(loggingType.type, source);
+			ClassLiteralAccess result = new ClassLiteralAccess(source.sourceEnd, copy);
 			Eclipse.setGeneratedBy(result, source);
 			return result;
 		};
diff --git a/src/core/lombok/extern/apachecommons/Log.java b/src/core/lombok/extern/apachecommons/Log.java
index 2afc2a6e..4c82a2a7 100644
--- a/src/core/lombok/extern/apachecommons/Log.java
+++ b/src/core/lombok/extern/apachecommons/Log.java
@@ -70,8 +70,6 @@ import java.lang.annotation.Target;
 public @interface Log {
 	/**
 	 * If you do not want to use the annotated class as the logger parameter, you can specify an alternate class here.
-	 * <br />
-	 * NB: If {@code void.class} is passed, it will be considered the same as specifying no parameter.
 	 */
 	Class<?> value() default void.class;
 }
\ No newline at end of file
diff --git a/src/core/lombok/extern/jul/Log.java b/src/core/lombok/extern/jul/Log.java
index c2e7428e..a66db671 100644
--- a/src/core/lombok/extern/jul/Log.java
+++ b/src/core/lombok/extern/jul/Log.java
@@ -70,8 +70,6 @@ import java.lang.annotation.Target;
 public @interface Log {
 	/**
 	 * If you do not want to use the annotated class as the logger parameter, you can specify an alternate class here.
- 	 * <br />
-	 * NB: If {@code void.class} is passed, it will be considered the same as specifying no parameter.
 	 */
 	Class<?> value() default void.class;
 }
\ No newline at end of file
diff --git a/src/core/lombok/extern/log4j/Log.java b/src/core/lombok/extern/log4j/Log.java
index e5fcbba0..151b5e98 100644
--- a/src/core/lombok/extern/log4j/Log.java
+++ b/src/core/lombok/extern/log4j/Log.java
@@ -70,8 +70,6 @@ import java.lang.annotation.Target;
 public @interface Log {
 	/**
 	 * If you do not want to use the annotated class as the logger parameter, you can specify an alternate class here.
- 	 * <br />
-	 * NB: If {@code void.class} is passed, it will be considered the same as specifying no parameter.
 	 */
 	Class<?> value() default void.class;
 }
\ No newline at end of file
diff --git a/src/core/lombok/extern/slf4j/Log.java b/src/core/lombok/extern/slf4j/Log.java
index 306ade16..5431847a 100644
--- a/src/core/lombok/extern/slf4j/Log.java
+++ b/src/core/lombok/extern/slf4j/Log.java
@@ -69,8 +69,6 @@ import java.lang.annotation.Target;
 public @interface Log {
 	/**
 	 * If you do not want to use the annotated class as the logger parameter, you can specify an alternate class here.
- 	 * <br />
-	 * NB: If {@code void.class} is passed, it will be considered the same as specifying no parameter.
 	 */
 	Class<?> value() default void.class;
 }
diff --git a/src/core/lombok/javac/handlers/HandleLog.java b/src/core/lombok/javac/handlers/HandleLog.java
index 771f6a2b..03e40d7f 100644
--- a/src/core/lombok/javac/handlers/HandleLog.java
+++ b/src/core/lombok/javac/handlers/HandleLog.java
@@ -26,9 +26,9 @@ import static lombok.javac.handlers.JavacHandlerUtil.*;
 import java.lang.annotation.Annotation;
 
 import lombok.core.AnnotationValues;
-import lombok.core.AST.Kind;
 import lombok.javac.JavacAnnotationHandler;
 import lombok.javac.JavacNode;
+import lombok.javac.handlers.JavacHandlerUtil.MemberExistsResult;
 
 import org.mangosdk.spi.ProviderFor;
 
@@ -37,9 +37,11 @@ import com.sun.tools.javac.tree.TreeMaker;
 import com.sun.tools.javac.tree.JCTree.JCAnnotation;
 import com.sun.tools.javac.tree.JCTree.JCClassDecl;
 import com.sun.tools.javac.tree.JCTree.JCExpression;
+import com.sun.tools.javac.tree.JCTree.JCFieldAccess;
 import com.sun.tools.javac.tree.JCTree.JCMethodInvocation;
 import com.sun.tools.javac.tree.JCTree.JCVariableDecl;
 import com.sun.tools.javac.util.List;
+import com.sun.tools.javac.util.Name;
 
 public class HandleLog {
 	
@@ -50,9 +52,18 @@ public class HandleLog {
 	public static boolean processAnnotation(LoggingFramework framework, AnnotationValues<?> annotation, JavacNode annotationNode) {
 		markAnnotationAsProcessed(annotationNode, framework.getAnnotationClass());
 		
-		String loggingClassName = annotation.getRawExpression("value");
-		if (loggingClassName == null) loggingClassName = "void";
-		if (loggingClassName.endsWith(".class")) loggingClassName = loggingClassName.substring(0, loggingClassName.length() - 6);
+//		String loggingClassName = annotation.getRawExpression("value");
+//		if (loggingClassName == null) loggingClassName = "void";
+//		if (loggingClassName.endsWith(".class")) loggingClassName = loggingClassName.substring(0, loggingClassName.length() - 6);
+		
+		JCExpression annotationValue = (JCExpression) annotation.getActualExpression("value");
+		JCFieldAccess loggingType = null; 
+		if (annotationValue != null) {
+			if (!(annotationValue instanceof JCFieldAccess)) return true;
+			loggingType = (JCFieldAccess) annotationValue;
+			if (!loggingType.name.contentEquals("class")) return true; 
+		}
+		
 		
 		JavacNode typeNode = annotationNode.up();
 		switch (typeNode.getKind()) {
@@ -67,10 +78,10 @@ public class HandleLog {
 				return true;
 			}
 
-			if (loggingClassName.equals("void")) {
-				loggingClassName = getSelfName(typeNode);
+			if (loggingType == null) {
+				loggingType = selfType(typeNode);
 			}
-			createField(framework, typeNode, loggingClassName);
+			createField(framework, typeNode, loggingType);
 			return true;
 		default:
 			annotationNode.addError("@Log is legal only on types.");
@@ -78,29 +89,20 @@ public class HandleLog {
 		}
 	}
 	
-	private static String getSelfName(JavacNode typeNode) {
-		String typeName = ((JCClassDecl) typeNode.get()).name.toString();
-		JavacNode upType = typeNode.up();
-		while (upType.getKind() == Kind.TYPE) {
-			typeName = ((JCClassDecl) upType.get()).name.toString() + "." + typeName;
-			upType = upType.up();
-		}
-		
-		String packageDeclaration = typeNode.getPackageDeclaration();
-		if (packageDeclaration != null) {
-			typeName = packageDeclaration + "." + typeName;
-		}
-		return typeName;
+	private static JCFieldAccess selfType(JavacNode typeNode) {
+		TreeMaker maker = typeNode.getTreeMaker();
+		Name name = ((JCClassDecl) typeNode.get()).name;
+		return maker.Select(maker.Ident(name), typeNode.toName("class"));
 	}
 	
-	private static boolean createField(LoggingFramework framework, JavacNode typeNode, String loggerClassName) {
+	private static boolean createField(LoggingFramework framework, JavacNode typeNode, JCFieldAccess loggingType) {
 		TreeMaker maker = typeNode.getTreeMaker();
 		
 		// 	private static final <loggerType> log = <factoryMethod>(<parameter>);
 		JCExpression loggerType = chainDotsString(maker, typeNode, framework.getLoggerTypeName());
 		JCExpression factoryMethod = chainDotsString(maker, typeNode, framework.getLoggerFactoryMethodName());
 		
-		JCExpression loggerName = framework.createFactoryParameter(typeNode, loggerClassName);
+		JCExpression loggerName = framework.createFactoryParameter(typeNode, loggingType);
 		JCMethodInvocation factoryMethodCall = maker.Apply(List.<JCExpression>nil(), factoryMethod, List.<JCExpression>of(loggerName));
 		
 		JCVariableDecl fieldDecl = maker.VarDef(
@@ -157,10 +159,9 @@ public class HandleLog {
 		
 		// private static final java.util.logging.Logger log = java.util.logging.Logger.getLogger(TargetType.class.getName());
 		JUL(lombok.extern.jul.Log.class, "java.util.logging.Logger", "java.util.logging.Logger.getLogger") {
-			@Override public JCExpression createFactoryParameter(JavacNode typeNode, String typeName) {
+			@Override public JCExpression createFactoryParameter(JavacNode typeNode, JCFieldAccess loggingType) {
 				TreeMaker maker = typeNode.getTreeMaker();
-				JCExpression classAccess = super.createFactoryParameter(typeNode, typeName);
-				JCExpression method = maker.Select(classAccess, typeNode.toName("getName"));
+				JCExpression method = maker.Select(loggingType, typeNode.toName("getName"));
 				return maker.Apply(List.<JCExpression>nil(), method, List.<JCExpression>nil());
 			}
 		},
@@ -195,8 +196,8 @@ public class HandleLog {
 			return loggerFactoryName;
 		}
 		
-		JCExpression createFactoryParameter(JavacNode typeNode, String typeName) {
-			return chainDotsString(typeNode.getTreeMaker(), typeNode, typeName + ".class");
+		JCExpression createFactoryParameter(JavacNode typeNode, JCFieldAccess loggingType) {
+			return loggingType;
 		}
 	}
 }