Intial support for @Log, for now only slf4j

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

@@ -404,11 +404,19 @@ public class EclipseHandlerUtil {
 		return null;
 	}
 	
+	/**
+	 * Inserts a field into an existing type. The type must represent a {@code TypeDeclaration}.
+	 * The field carries the @{@link SuppressWarnings}("all") annotation.
+	 */
+	public static void injectFieldSuppressWarnings(EclipseNode type, FieldDeclaration field) {
+		field.annotations = createSuppressWarningsAll(field, field.annotations);
+		injectField(type, field);
+	}
+	
 	/**
 	 * Inserts a field into an existing type. The type must represent a {@code TypeDeclaration}.
 	 */
 	public static void injectField(EclipseNode type, FieldDeclaration field) {
-		field.annotations = createSuppressWarningsAll(field, field.annotations);
 		TypeDeclaration parent = (TypeDeclaration) type.get();
 		
 		if (parent.fields == null) {

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

@@ -0,0 +1,158 @@
+/*
+ * Copyright © 2009 Reinier Zwitserloot, Roel Spilker and Robbert Jan Grootjans.
+ * 
+ * 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.eclipse.handlers;
+
+import static lombok.eclipse.Eclipse.fromQualifiedName;
+import static lombok.eclipse.handlers.EclipseHandlerUtil.*;
+
+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;
+import lombok.eclipse.handlers.EclipseHandlerUtil.MemberExistsResult;
+import lombok.slf4j.Log;
+
+import org.eclipse.jdt.internal.compiler.ast.Annotation;
+import org.eclipse.jdt.internal.compiler.ast.Expression;
+import org.eclipse.jdt.internal.compiler.ast.FieldDeclaration;
+import org.eclipse.jdt.internal.compiler.ast.MessageSend;
+import org.eclipse.jdt.internal.compiler.ast.QualifiedNameReference;
+import org.eclipse.jdt.internal.compiler.ast.QualifiedTypeReference;
+import org.eclipse.jdt.internal.compiler.ast.TypeDeclaration;
+import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;
+import org.mangosdk.spi.ProviderFor;
+
+/**
+ * Handles the {@code lombok.HandleSneakyThrows} annotation for eclipse.
+ */
+@ProviderFor(EclipseAnnotationHandler.class)
+public class HandleSlf4jLog implements EclipseAnnotationHandler<Log> {
+	
+	@Override public boolean handle(AnnotationValues<Log> annotation, Annotation source, EclipseNode annotationNode) {
+		
+		String loggingClassName = annotation.getRawExpression("value");
+		if (loggingClassName == null) loggingClassName = "void.class";
+		if (!loggingClassName.endsWith(".class")) loggingClassName = loggingClassName + ".class";
+		
+		EclipseNode owner = annotationNode.up();
+		switch (owner.getKind()) {
+		case TYPE:
+			TypeDeclaration typeDecl = null;
+			if (owner.get() instanceof TypeDeclaration) typeDecl = (TypeDeclaration) owner.get();
+			int modifiers = typeDecl == null ? 0 : typeDecl.modifiers;
+			
+			boolean notAClass = (modifiers &
+					(ClassFileConstants.AccInterface | ClassFileConstants.AccAnnotation)) != 0;
+			
+			if (typeDecl == null || notAClass) {
+				annotationNode.addError("@Log is legal only on classes and enums.");
+				return false;
+			}
+			
+			
+			if (loggingClassName.equals("void.class")) {
+				loggingClassName = getSelfName(owner);
+			}
+			
+			return handleType(annotationNode, source, loggingClassName);
+		default:
+			annotationNode.addError("@Log is legal only on types.");
+			return true;
+		}
+	}
+	
+	private 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 + ".class";
+	}
+	
+	private String getSingleTypeName(EclipseNode type) {
+		TypeDeclaration typeDeclaration = (TypeDeclaration)type.get();
+		char[] rawTypeName = typeDeclaration.name;
+		return rawTypeName == null ? "" : new String(rawTypeName);
+	}
+	
+	private boolean handleType(EclipseNode annotation, Annotation source, String loggingClassName) {
+		int pS = source.sourceStart, pE = source.sourceEnd;
+		long p = (long)pS << 32 | pE;
+		
+		EclipseNode typeNode = annotation.up();
+
+		MemberExistsResult fieldExists = fieldExists("log", typeNode);
+		switch (fieldExists) {
+		case NOT_EXISTS:
+			// 	private static final org.slf4j.Logger log = org.slf4j.LoggerFactory.getLogger(LoggerLog4j.class);
+
+			FieldDeclaration fieldDecl = new FieldDeclaration("log".toCharArray(), 0, -1);
+			Eclipse.setGeneratedBy(fieldDecl, source);
+			fieldDecl.declarationSourceEnd = -1;
+			fieldDecl.modifiers = Modifier.PRIVATE | Modifier.STATIC | Modifier.FINAL;
+			
+			fieldDecl.type = new QualifiedTypeReference(fromQualifiedName("org.slf4j.Logger"), new long[]{p, p, p});
+			Eclipse.setGeneratedBy(fieldDecl.type, source);
+			
+			MessageSend factoryMethodCall = new MessageSend();
+			Eclipse.setGeneratedBy(factoryMethodCall, source);
+			factoryMethodCall.receiver = new QualifiedNameReference(fromQualifiedName("org.slf4j.LoggerFactory"), new long[] { p, p, p }, pS, pE);
+			Eclipse.setGeneratedBy(factoryMethodCall.receiver, source);
+			factoryMethodCall.receiver.statementEnd = pE;
+			factoryMethodCall.selector = "getLogger".toCharArray();
+			
+			char[][] loggingClassNameTokens = fromQualifiedName(loggingClassName);
+			long[] posses = new long[loggingClassNameTokens.length];
+			Arrays.fill(posses, p);
+			
+			QualifiedNameReference exRef = new QualifiedNameReference(loggingClassNameTokens, posses, pS, pE);
+			Eclipse.setGeneratedBy(exRef, source);
+			exRef.statementEnd = pE;
+			
+			factoryMethodCall.arguments = new Expression[] { exRef };
+			factoryMethodCall.nameSourcePosition = p;
+			factoryMethodCall.sourceStart = pS;
+			factoryMethodCall.sourceEnd = factoryMethodCall.statementEnd = pE;
+			
+			fieldDecl.initialization = factoryMethodCall;
+			injectField(annotation.up(), fieldDecl);
+
+			annotation.up().rebuild();
+			
+			return true;
+		case EXISTS_BY_USER:
+			annotation.addWarning("Field 'log' already exists.");
+		}
+		
+		return true;
+	}
+}

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

@@ -101,7 +101,7 @@ public class HandleSynchronized implements EclipseAnnotationHandler<Synchronized
 			fieldDecl.type = new QualifiedTypeReference(TypeConstants.JAVA_LANG_OBJECT, new long[] { 0, 0, 0 });
 			Eclipse.setGeneratedBy(fieldDecl.type, source);
 			fieldDecl.initialization = arrayAlloc;
-			injectField(annotationNode.up().up(), fieldDecl);
+			injectFieldSuppressWarnings(annotationNode.up().up(), fieldDecl);
 		}
 		
 		if (method.statements == null) return false;

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

@@ -0,0 +1,114 @@
+/*
+ * Copyright © 2010 Reinier Zwitserloot, Roel Spilker and Robbert Jan Grootjans.
+ * 
+ * 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.javac.handlers;
+
+import static lombok.javac.handlers.JavacHandlerUtil.*;
+import lombok.core.AnnotationValues;
+import lombok.core.AST.Kind;
+import lombok.javac.JavacAnnotationHandler;
+import lombok.javac.JavacNode;
+import lombok.slf4j.Log;
+
+import org.mangosdk.spi.ProviderFor;
+
+import com.sun.tools.javac.code.Flags;
+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.JCMethodInvocation;
+import com.sun.tools.javac.tree.JCTree.JCVariableDecl;
+import com.sun.tools.javac.util.List;
+
+/**
+ * Handles the {@code lombok.slf4j.Log} annotation for javac.
+ */
+@ProviderFor(JavacAnnotationHandler.class)
+public class HandleSlf4jLog implements JavacAnnotationHandler<Log> {
+	@Override public boolean handle(AnnotationValues<Log> annotation, JCAnnotation ast, JavacNode annotationNode) {
+		markAnnotationAsProcessed(annotationNode, Log.class);
+		
+		String loggingClassName = annotation.getRawExpression("value");
+		if (loggingClassName == null) loggingClassName = "void.class";
+		if (!loggingClassName.endsWith(".class")) loggingClassName = loggingClassName + ".class";
+		
+		
+		JavacNode owner = annotationNode.up();
+		switch (owner.getKind()) {
+		case TYPE:
+			if ((((JCClassDecl)owner.get()).mods.flags & Flags.INTERFACE)!= 0) {
+				annotationNode.addError("@Log is legal only on classes and enums.");
+				return true;
+			}
+			
+			if (loggingClassName.equals("void.class")) {
+				loggingClassName = getSelfName(owner);
+			}
+			return handleType(annotationNode, loggingClassName);
+		default:
+			annotationNode.addError("@Log is legal only on types.");
+			return true;
+		}
+	}
+	
+	private 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 + ".class";
+	}
+	
+	private boolean handleType(JavacNode annotation, String loggerClassName) {
+		JavacNode typeNode = annotation.up();
+		
+		TreeMaker maker = typeNode.getTreeMaker();
+		
+		switch (fieldExists("log", typeNode)) {
+		case NOT_EXISTS: 
+			// 	private static final org.slf4j.Logger log = org.slf4j.LoggerFactory.getLogger(LoggerLog4j.class);
+			JCExpression loggerType = chainDots(maker, typeNode, "org", "slf4j", "Logger");
+			JCExpression factoryMethod = chainDots(maker, typeNode, "org", "slf4j", "LoggerFactory", "getLogger");
+			
+			JCExpression loggerName = chainDots(maker, typeNode, loggerClassName.split("\\."));
+			JCMethodInvocation factoryMethodCall = maker.Apply(List.<JCExpression>nil(), factoryMethod, List.<JCExpression>of(loggerName));
+			
+			JCVariableDecl fieldDecl = maker.VarDef(
+					maker.Modifiers(Flags.PRIVATE | Flags.FINAL | Flags.STATIC),
+					typeNode.toName("log"), loggerType, factoryMethodCall);
+			
+			injectField(typeNode, fieldDecl);
+			return true;
+		case EXISTS_BY_USER: 
+			annotation.addWarning("Field 'log' already exists.");
+		}
+		
+		return true;
+	}
+}

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

@@ -89,7 +89,7 @@ public class HandleSynchronized implements JavacAnnotationHandler<Synchronized>
 			JCVariableDecl fieldDecl = maker.VarDef(
 					maker.Modifiers(Flags.PRIVATE | Flags.FINAL | (isStatic ? Flags.STATIC : 0)),
 					methodNode.toName(lockName), objectType, newObjectArray);
-			injectField(methodNode.up(), fieldDecl);
+			injectFieldSuppressWarnings(methodNode.up(), fieldDecl);
 		}
 		
 		if (method.body == null) return false;

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

@@ -390,15 +390,28 @@ public class JavacHandlerUtil {
 		return call;
 	}
 	
+	/**
+	 * Adds the given new field declaration to the provided type AST Node.
+	 * The field carries the @{@link SuppressWarnings}("all") annotation.
+	 * Also takes care of updating the JavacAST.
+	 */
+	public static void injectFieldSuppressWarnings(JavacNode typeNode, JCVariableDecl field) {
+		injectField(typeNode, field, true);
+	}
+	
 	/**
 	 * Adds the given new field declaration to the provided type AST Node.
 	 * 
 	 * Also takes care of updating the JavacAST.
 	 */
 	public static void injectField(JavacNode typeNode, JCVariableDecl field) {
+		injectField(typeNode, field, false);
+	}
+
+	private static void injectField(JavacNode typeNode, JCVariableDecl field, boolean addSuppressWarnings) {
 		JCClassDecl type = (JCClassDecl) typeNode.get();
 		
-		addSuppressWarningsAll(field.mods, typeNode, field.pos);
+		if (addSuppressWarnings) addSuppressWarningsAll(field.mods, typeNode, field.pos);
 		type.defs = type.defs.append(field);
 		
 		typeNode.add(field, Kind.FIELD).recursiveSetHandled();

src/core/lombok/slf4j/Log.java

@@ -0,0 +1,34 @@
+/*
+ * Copyright © 2010 Reinier Zwitserloot, Roel Spilker and Robbert Jan Grootjans.
+ * 
+ * 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.slf4j;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Retention(RetentionPolicy.SOURCE)
+@Target(ElementType.TYPE)
+public @interface Log {
+	
+	Class<?> value() default void.class;
+}

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

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

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

@@ -0,0 +1,3 @@
+class LoggerSlf4jAlreadyExists {
+	int log;
+}

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

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

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

@@ -0,0 +1,4 @@
+class LoggerSlf4jOnNonType {
+	void foo() {
+	}
+}

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

@@ -0,0 +1,17 @@
+interface LoggerSlf4jTypesInterface {
+}
+@interface LoggerSlf4jTypesAnnotation {
+}
+enum LoggerSlf4jTypesEnum {
+;
+	private static final org.slf4j.Logger log = org.slf4j.LoggerFactory.getLogger(LoggerSlf4jTypesEnum.class);
+}
+enum LoggerSlf4jTypesEnumWithElement {
+	FOO;
+	private static final org.slf4j.Logger log = org.slf4j.LoggerFactory.getLogger(LoggerSlf4jTypesEnumWithElement.class);
+}
+interface LoggerSlf4jTypesInterfaceOuter {
+	class Inner {
+		private static final org.slf4j.Logger log = org.slf4j.LoggerFactory.getLogger(LoggerSlf4jTypesInterfaceOuter.Inner.class);
+	}
+}

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

@@ -0,0 +1,12 @@
+class LoggerSlf4jWithClass {
+	private static final org.slf4j.Logger log = org.slf4j.LoggerFactory.getLogger(String.class);
+}
+class LoggerSlf4jWithClassList {
+	private static final org.slf4j.Logger log = org.slf4j.LoggerFactory.getLogger(java.util.List.class);
+}
+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);
+}

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

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

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

@@ -0,0 +1,17 @@
+@lombok.slf4j.Log class LoggerSlf4j {
+  private static final org.slf4j.Logger log = org.slf4j.LoggerFactory.getLogger(LoggerSlf4j.class);
+  LoggerSlf4j() {
+    super();
+  }
+}
+class LoggerSlf4jOuter {
+  static @lombok.slf4j.Log class Inner {
+    private static final org.slf4j.Logger log = org.slf4j.LoggerFactory.getLogger(LoggerSlf4jOuter.Inner.class);
+    Inner() {
+      super();
+    }
+  }
+  LoggerSlf4jOuter() {
+    super();
+  }
+}

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

@@ -0,0 +1,6 @@
+@lombok.slf4j.Log class LoggerSlf4jAlreadyExists {
+  int log;
+  LoggerSlf4jAlreadyExists() {
+    super();
+  }
+}

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

@@ -0,0 +1,6 @@
+@lombok.slf4j.Log(String[].class) class LoggerSlf4jClassOfArray {
+  private static final org.slf4j.Logger log = org.slf4j.LoggerFactory.getLogger(String[].class);
+  LoggerSlf4jClassOfArray() {
+    super();
+  }
+}

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

@@ -0,0 +1,7 @@
+class LoggerSlf4jOnNonType {
+  LoggerSlf4jOnNonType() {
+    super();
+  }
+  @lombok.slf4j.Log void foo() {
+  }
+}

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

@@ -0,0 +1,29 @@
+@lombok.slf4j.Log interface LoggerSlf4jTypesInterface {
+}
+@lombok.slf4j.Log @interface LoggerSlf4jTypesAnnotation {
+}
+@lombok.slf4j.Log enum LoggerSlf4jTypesEnum {
+  private static final org.slf4j.Logger log = org.slf4j.LoggerFactory.getLogger(LoggerSlf4jTypesEnum.class);
+  <clinit>() {
+  }
+  LoggerSlf4jTypesEnum() {
+    super();
+  }
+}
+@lombok.slf4j.Log enum LoggerSlf4jTypesEnumWithElement {
+  FOO(),
+  private static final org.slf4j.Logger log = org.slf4j.LoggerFactory.getLogger(LoggerSlf4jTypesEnumWithElement.class);
+  <clinit>() {
+  }
+  LoggerSlf4jTypesEnumWithElement() {
+    super();
+  }
+}
+interface LoggerSlf4jTypesInterfaceOuter {
+  @lombok.slf4j.Log class Inner {
+    private static final org.slf4j.Logger log = org.slf4j.LoggerFactory.getLogger(LoggerSlf4jTypesInterfaceOuter.Inner.class);
+    Inner() {
+      super();
+    }
+  }
+}

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

@@ -0,0 +1,24 @@
+@lombok.slf4j.Log(String.class) class LoggerSlf4jWithClass {
+  private static final org.slf4j.Logger log = org.slf4j.LoggerFactory.getLogger(String.class);
+  LoggerSlf4jWithClass() {
+    super();
+  }
+}
+@lombok.slf4j.Log(java.util.List.class) class LoggerSlf4jWithClassList {
+  private static final org.slf4j.Logger log = org.slf4j.LoggerFactory.getLogger(java.util.List.class);
+  LoggerSlf4jWithClassList() {
+    super();
+  }
+}
+@lombok.slf4j.Log(value = java.lang.String.class) class LoggerSlf4jWithClassValue {
+  private static final org.slf4j.Logger log = org.slf4j.LoggerFactory.getLogger(java.lang.String.class);
+  LoggerSlf4jWithClassValue() {
+    super();
+  }
+}
+@lombok.slf4j.Log(void.class) class LoggerSlf4jWithClassVoid {
+  private static final org.slf4j.Logger log = org.slf4j.LoggerFactory.getLogger(LoggerSlf4jWithClassVoid.class);
+  LoggerSlf4jWithClassVoid() {
+    super();
+  }
+}

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

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

test/transform/resource/before/LoggerSlf4j.java

@@ -0,0 +1,9 @@
+@lombok.slf4j.Log
+class LoggerSlf4j {
+}
+class LoggerSlf4jOuter {
+	@lombok.slf4j.Log
+	static class Inner {
+		
+	}
+}

test/transform/resource/before/LoggerSlf4jAlreadyExists.java

@@ -0,0 +1,4 @@
+@lombok.slf4j.Log
+class LoggerSlf4jAlreadyExists {
+	int log;
+}

test/transform/resource/before/LoggerSlf4jClassOfArray.java

@@ -0,0 +1,3 @@
+@lombok.slf4j.Log(String[].class)
+class LoggerSlf4jClassOfArray {
+}

test/transform/resource/before/LoggerSlf4jOnNonType.java

@@ -0,0 +1,5 @@
+class LoggerSlf4jOnNonType {
+	@lombok.slf4j.Log
+	void foo() {
+	}
+}

test/transform/resource/before/LoggerSlf4jTypes.java

@@ -0,0 +1,18 @@
+@lombok.slf4j.Log
+interface LoggerSlf4jTypesInterface {
+}
+@lombok.slf4j.Log
+@interface LoggerSlf4jTypesAnnotation {
+}
+@lombok.slf4j.Log
+enum LoggerSlf4jTypesEnum {
+}
+@lombok.slf4j.Log
+enum LoggerSlf4jTypesEnumWithElement {
+	FOO;
+}
+interface LoggerSlf4jTypesInterfaceOuter {
+	@lombok.slf4j.Log
+	class Inner {
+	}
+}

test/transform/resource/before/LoggerSlf4jWithClass.java

@@ -0,0 +1,12 @@
+@lombok.slf4j.Log(String.class)
+class LoggerSlf4jWithClass {
+}
+@lombok.slf4j.Log(java.util.List.class)
+class LoggerSlf4jWithClassList {
+}
+@lombok.slf4j.Log(value = java.lang.String.class)
+class LoggerSlf4jWithClassValue {
+}
+@lombok.slf4j.Log(void.class)
+class LoggerSlf4jWithClassVoid {
+}

test/transform/resource/before/LoggerSlf4jWithPackage.java

@@ -0,0 +1,9 @@
+package before;
+@lombok.slf4j.Log
+class LoggerSlf4jWithPackage {
+}
+class LoggerSlf4jWithPackageOuter {
+	@lombok.slf4j.Log
+	static class Inner {
+	}
+}

test/transform/resource/messages-delombok/LoggerSlf4jAlreadyExists.java.messages

@@ -0,0 +1 @@
+1:1 WARNING Field 'log' already exists.

test/transform/resource/messages-delombok/LoggerSlf4jOnNonStaticInnerClass.java.messages

@@ -0,0 +1 @@
+2:9 ERROR @Log is not legal on non-static inner classes.

test/transform/resource/messages-delombok/LoggerSlf4jOnNonType.java.messages

@@ -0,0 +1 @@
+2:9 ERROR @Log is legal only on types.

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

@@ -0,0 +1,2 @@
+1:1 ERROR @Log is legal only on classes and enums.
+4:1 ERROR @Log is legal only on classes and enums.

test/transform/resource/messages-ecj/LoggerSlf4jAlreadyExists.java.messages

@@ -0,0 +1 @@
+1 warning Field 'log' already exists.

test/transform/resource/messages-ecj/LoggerSlf4jOnNonStaticInnerClass.java.messages

@@ -0,0 +1 @@
+2:9 ERROR @Log is not legal on non-static inner classes.

test/transform/resource/messages-ecj/LoggerSlf4jOnNonType.java.messages

@@ -0,0 +1 @@
+2 error @Log is legal only on types.

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

@@ -0,0 +1,2 @@
+1 error @Log is legal only on classes and enums.
+4 error @Log is legal only on classes and enums.