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

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;
 		};

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;
 }

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;
 }

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;
 }

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;
 }

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;
 		}
 	}
 }

test/transform/resource/after-delombok/LoggerSlf4j.java

@@ -3,6 +3,6 @@ class LoggerSlf4j {
 }
 class LoggerSlf4jOuter {
 	static class Inner {
-		private static final org.slf4j.Logger log = org.slf4j.LoggerFactory.getLogger(LoggerSlf4jOuter.Inner.class);
+		private static final org.slf4j.Logger log = org.slf4j.LoggerFactory.getLogger(Inner.class);
 	}
 }

test/transform/resource/after-delombok/LoggerSlf4jClassOfArray.java

@@ -1,3 +1,6 @@
 class LoggerSlf4jClassOfArray {
 	private static final org.slf4j.Logger log = org.slf4j.LoggerFactory.getLogger(String[].class);
 }
+class LoggerSlf4jClassOfArrayJLS {
+	private static final org.slf4j.Logger log = org.slf4j.LoggerFactory.getLogger(java.lang.String[].class);
+}

test/transform/resource/after-delombok/LoggerSlf4jTypes.java

@@ -12,6 +12,6 @@ enum LoggerSlf4jTypesEnumWithElement {
 }
 interface LoggerSlf4jTypesInterfaceOuter {
 	class Inner {
-		private static final org.slf4j.Logger log = org.slf4j.LoggerFactory.getLogger(LoggerSlf4jTypesInterfaceOuter.Inner.class);
+		private static final org.slf4j.Logger log = org.slf4j.LoggerFactory.getLogger(Inner.class);
 	}
 }

test/transform/resource/after-delombok/LoggerSlf4jWithClass.java

@@ -8,5 +8,5 @@ class LoggerSlf4jWithClassValue {
 	private static final org.slf4j.Logger log = org.slf4j.LoggerFactory.getLogger(java.lang.String.class);
 }
 class LoggerSlf4jWithClassVoid {
-	private static final org.slf4j.Logger log = org.slf4j.LoggerFactory.getLogger(LoggerSlf4jWithClassVoid.class);
+	private static final org.slf4j.Logger log = org.slf4j.LoggerFactory.getLogger(void.class);
 }

test/transform/resource/after-delombok/LoggerSlf4jWithPackage.java

@@ -1,9 +1,9 @@
 package before;
 class LoggerSlf4jWithPackage {
-	private static final org.slf4j.Logger log = org.slf4j.LoggerFactory.getLogger(before.LoggerSlf4jWithPackage.class);
+	private static final org.slf4j.Logger log = org.slf4j.LoggerFactory.getLogger(LoggerSlf4jWithPackage.class);
 }
 class LoggerSlf4jWithPackageOuter {
 	static class Inner {
-		private static final org.slf4j.Logger log = org.slf4j.LoggerFactory.getLogger(before.LoggerSlf4jWithPackageOuter.Inner.class);
+		private static final org.slf4j.Logger log = org.slf4j.LoggerFactory.getLogger(Inner.class);
 	}
 }

test/transform/resource/after-ecj/LoggerSlf4j.java

@@ -8,7 +8,7 @@
 }
 class LoggerSlf4jOuter {
   static @lombok.extern.slf4j.Log class Inner {
-    private static final org.slf4j.Logger log = org.slf4j.LoggerFactory.getLogger(LoggerSlf4jOuter.Inner.class);
+    private static final org.slf4j.Logger log = org.slf4j.LoggerFactory.getLogger(Inner.class);
     <clinit>() {
     }
     Inner() {

test/transform/resource/after-ecj/LoggerSlf4jClassOfArray.java

@@ -5,4 +5,12 @@
   LoggerSlf4jClassOfArray() {
     super();
   }
+}
+@lombok.extern.slf4j.Log(java.lang.String[].class) class LoggerSlf4jClassOfArrayJLS {
+  private static final org.slf4j.Logger log = org.slf4j.LoggerFactory.getLogger(java.lang.String[].class);
+  <clinit>() {
+  }
+  LoggerSlf4jClassOfArrayJLS() {
+    super();
+  }
 }

test/transform/resource/after-ecj/LoggerSlf4jTypes.java

@@ -21,7 +21,7 @@
 }
 interface LoggerSlf4jTypesInterfaceOuter {
   @lombok.extern.slf4j.Log class Inner {
-    private static final org.slf4j.Logger log = org.slf4j.LoggerFactory.getLogger(LoggerSlf4jTypesInterfaceOuter.Inner.class);
+    private static final org.slf4j.Logger log = org.slf4j.LoggerFactory.getLogger(Inner.class);
     <clinit>() {
     }
     Inner() {

test/transform/resource/after-ecj/LoggerSlf4jWithClass.java

@@ -23,7 +23,7 @@
   }
 }
 @lombok.extern.slf4j.Log(void.class) class LoggerSlf4jWithClassVoid {
-  private static final org.slf4j.Logger log = org.slf4j.LoggerFactory.getLogger(LoggerSlf4jWithClassVoid.class);
+  private static final org.slf4j.Logger log = org.slf4j.LoggerFactory.getLogger(void.class);
   <clinit>() {
   }
   LoggerSlf4jWithClassVoid() {

test/transform/resource/after-ecj/LoggerSlf4jWithPackage.java

@@ -1,6 +1,6 @@
 package before;
 @lombok.extern.slf4j.Log class LoggerSlf4jWithPackage {
-  private static final org.slf4j.Logger log = org.slf4j.LoggerFactory.getLogger(before.LoggerSlf4jWithPackage.class);
+  private static final org.slf4j.Logger log = org.slf4j.LoggerFactory.getLogger(LoggerSlf4jWithPackage.class);
   <clinit>() {
   }
   LoggerSlf4jWithPackage() {
@@ -9,7 +9,7 @@ package before;
 }
 class LoggerSlf4jWithPackageOuter {
   static @lombok.extern.slf4j.Log class Inner {
-    private static final org.slf4j.Logger log = org.slf4j.LoggerFactory.getLogger(before.LoggerSlf4jWithPackageOuter.Inner.class);
+    private static final org.slf4j.Logger log = org.slf4j.LoggerFactory.getLogger(Inner.class);
     <clinit>() {
     }
     Inner() {

test/transform/resource/before/LoggerSlf4jClassOfArray.java

@@ -1,3 +1,6 @@
 @lombok.extern.slf4j.Log(String[].class)
 class LoggerSlf4jClassOfArray {
 }
+@lombok.extern.slf4j.Log(java.lang.String[].class)
+class LoggerSlf4jClassOfArrayJLS {
+}

website/features/Log.html

@@ -51,9 +51,6 @@
 				<p>
 				If a field called <code>log</code> already exists, a warning will be emitted and no code will be generated.
 				</p>
-				<p>
-				Although it is possible to specify any class literal to pass to the logger factory method, passing <code>void.class</code> will be considered to be the same as specifying no parameter.
-				</p>
 			</div>
 		</div>
 		<div class="footer">