7 files changed, 331 insertions, 4 deletions
diff --git a/src/core/lombok/eclipse/handlers/EclipseHandlerUtil.java b/src/core/lombok/eclipse/handlers/EclipseHandlerUtil.java
index 5005752b..29937279 100644
--- a/src/core/lombok/eclipse/handlers/EclipseHandlerUtil.java
+++ b/src/core/lombok/eclipse/handlers/EclipseHandlerUtil.java
@@ -406,9 +406,17 @@ public class EclipseHandlerUtil {
 	
 	/**
 	 * Inserts a field into an existing type. The type must represent a {@code TypeDeclaration}.
+	 * The field carries the &#64;{@link SuppressWarnings}("all") annotation.
 	 */
-	public static void injectField(EclipseNode type, FieldDeclaration field) {
+	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) {
 		TypeDeclaration parent = (TypeDeclaration) type.get();
 		
 		if (parent.fields == null) {
diff --git a/src/core/lombok/eclipse/handlers/HandleSlf4jLog.java b/src/core/lombok/eclipse/handlers/HandleSlf4jLog.java
new file mode 100644
index 00000000..c9046260
--- /dev/null
+++ b/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;
+	}
+}
diff --git a/src/core/lombok/eclipse/handlers/HandleSynchronized.java b/src/core/lombok/eclipse/handlers/HandleSynchronized.java
index fde36192..b77099b5 100644
--- a/src/core/lombok/eclipse/handlers/HandleSynchronized.java
+++ b/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;
diff --git a/src/core/lombok/javac/handlers/HandleSlf4jLog.java b/src/core/lombok/javac/handlers/HandleSlf4jLog.java
new file mode 100644
index 00000000..01e0b69e
--- /dev/null
+++ b/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;
+	}
+}
diff --git a/src/core/lombok/javac/handlers/HandleSynchronized.java b/src/core/lombok/javac/handlers/HandleSynchronized.java
index 2f900eb8..a095aaf1 100644
--- a/src/core/lombok/javac/handlers/HandleSynchronized.java
+++ b/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;
diff --git a/src/core/lombok/javac/handlers/JavacHandlerUtil.java b/src/core/lombok/javac/handlers/JavacHandlerUtil.java
index 79436327..3e734f8b 100644
--- a/src/core/lombok/javac/handlers/JavacHandlerUtil.java
+++ b/src/core/lombok/javac/handlers/JavacHandlerUtil.java
@@ -392,13 +392,26 @@ public class JavacHandlerUtil {
 	
 	/**
 	 * Adds the given new field declaration to the provided type AST Node.
+	 * The field carries the &#64;{@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();
diff --git a/src/core/lombok/slf4j/Log.java b/src/core/lombok/slf4j/Log.java
new file mode 100644
index 00000000..4a82e239
--- /dev/null
+++ b/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;
+}