From 8e7334a50535ef33189c3e71fcab0d9e625c6534 Mon Sep 17 00:00:00 2001 From: Roel Spilker Date: Sat, 6 Nov 2010 23:29:43 +0100 Subject: Updated documentation on @Log and moved them all to lombok.extern.* --- src/core/lombok/extern/slf4j/Log.java | 76 +++++++++++++++++++++++++++++++++++ 1 file changed, 76 insertions(+) create mode 100644 src/core/lombok/extern/slf4j/Log.java (limited to 'src/core/lombok/extern/slf4j/Log.java') diff --git a/src/core/lombok/extern/slf4j/Log.java b/src/core/lombok/extern/slf4j/Log.java new file mode 100644 index 00000000..306ade16 --- /dev/null +++ b/src/core/lombok/extern/slf4j/Log.java @@ -0,0 +1,76 @@ +/* + * 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.extern.slf4j; + +import java.lang.annotation.ElementType; +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; +/** + * Causes lombok to generate a logger field. + * Example: + * 
+ * @Log
+ * public class LogExample {
+ * }
+ *
+ * + * will generate: + * + * 
+ * public class LogExample {
+ *     private static final org.slf4j.Logger log = org.slf4j.LoggerFactory.getLogger(LogExample.class);
+ * }
+ *
+ * + * If you do not want to use the annotated class as the logger parameter, you can specify an alternate class. + * Example: + * 
+ * @Log(java.util.List.class)
+ * public class LogExample {
+ * }
+ *
+ * + * will generate: + * + * 
+ * public class LogExample {
+ *     private static final org.slf4j.Logger log = org.slf4j.LoggerFactory.getLogger(java.util.List.class); 
+ * }
+ *
+ * + * This annotation is valid for classes and enumerations.
+ * + * @see lombok.extern.apachecommons.Log lombok.extern.apachecommons.Log + * @see lombok.extern.jul.Log lombok.extern.jul.Log + * @see lombok.extern.log4j.Log lombok.extern.log4j.Log + */ +@Retention(RetentionPolicy.SOURCE) +@Target(ElementType.TYPE) +public @interface Log { + /** + * If you do not want to use the annotated class as the logger parameter, you can specify an alternate class here. + *
+ * NB: If {@code void.class} is passed, it will be considered the same as specifying no parameter. + */ + Class value() default void.class; +} -- cgit From 1f0db1191a7fcc35aaeab1481a806201a450d797 Mon Sep 17 00:00:00 2001 From: Roel Spilker Date: Sun, 7 Nov 2010 02:49:01 +0100 Subject: Use the actual annotation value to process the @Log annotations instead of their String representations. --- src/core/lombok/eclipse/handlers/HandleLog.java | 75 +++++++++++----------- src/core/lombok/extern/apachecommons/Log.java | 2 - src/core/lombok/extern/jul/Log.java | 2 - src/core/lombok/extern/log4j/Log.java | 2 - src/core/lombok/extern/slf4j/Log.java | 2 - src/core/lombok/javac/handlers/HandleLog.java | 55 ++++++++-------- .../resource/after-delombok/LoggerSlf4j.java | 2 +- .../after-delombok/LoggerSlf4jClassOfArray.java | 3 + .../resource/after-delombok/LoggerSlf4jTypes.java | 2 +- .../after-delombok/LoggerSlf4jWithClass.java | 2 +- .../after-delombok/LoggerSlf4jWithPackage.java | 4 +- test/transform/resource/after-ecj/LoggerSlf4j.java | 2 +- .../after-ecj/LoggerSlf4jClassOfArray.java | 8 +++ .../resource/after-ecj/LoggerSlf4jTypes.java | 2 +- .../resource/after-ecj/LoggerSlf4jWithClass.java | 2 +- .../resource/after-ecj/LoggerSlf4jWithPackage.java | 4 +- .../resource/before/LoggerSlf4jClassOfArray.java | 3 + website/features/Log.html | 3 - 18 files changed, 91 insertions(+), 84 deletions(-) (limited to 'src/core/lombok/extern/slf4j/Log.java') 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 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. - *
- * 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. - *
- * 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. - *
- * 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. - *
- * 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 log = (); 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.nil(), factoryMethod, List.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.nil(), method, List.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; } } } diff --git a/test/transform/resource/after-delombok/LoggerSlf4j.java b/test/transform/resource/after-delombok/LoggerSlf4j.java index dae17826..c7c84631 100644 --- a/test/transform/resource/after-delombok/LoggerSlf4j.java +++ b/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); } } \ No newline at end of file diff --git a/test/transform/resource/after-delombok/LoggerSlf4jClassOfArray.java b/test/transform/resource/after-delombok/LoggerSlf4jClassOfArray.java index bcae2741..00b44d5c 100644 --- a/test/transform/resource/after-delombok/LoggerSlf4jClassOfArray.java +++ b/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); +} diff --git a/test/transform/resource/after-delombok/LoggerSlf4jTypes.java b/test/transform/resource/after-delombok/LoggerSlf4jTypes.java index 539f46d6..4950bc88 100644 --- a/test/transform/resource/after-delombok/LoggerSlf4jTypes.java +++ b/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); } } \ No newline at end of file diff --git a/test/transform/resource/after-delombok/LoggerSlf4jWithClass.java b/test/transform/resource/after-delombok/LoggerSlf4jWithClass.java index 5908d374..b4e2181e 100644 --- a/test/transform/resource/after-delombok/LoggerSlf4jWithClass.java +++ b/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); } diff --git a/test/transform/resource/after-delombok/LoggerSlf4jWithPackage.java b/test/transform/resource/after-delombok/LoggerSlf4jWithPackage.java index 516f858f..b337bd02 100644 --- a/test/transform/resource/after-delombok/LoggerSlf4jWithPackage.java +++ b/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); } } diff --git a/test/transform/resource/after-ecj/LoggerSlf4j.java b/test/transform/resource/after-ecj/LoggerSlf4j.java index 24682e97..e635ece8 100644 --- a/test/transform/resource/after-ecj/LoggerSlf4j.java +++ b/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); () { } Inner() { diff --git a/test/transform/resource/after-ecj/LoggerSlf4jClassOfArray.java b/test/transform/resource/after-ecj/LoggerSlf4jClassOfArray.java index a3dad07b..20fe0fde 100644 --- a/test/transform/resource/after-ecj/LoggerSlf4jClassOfArray.java +++ b/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); + () { + } + LoggerSlf4jClassOfArrayJLS() { + super(); + } } \ No newline at end of file diff --git a/test/transform/resource/after-ecj/LoggerSlf4jTypes.java b/test/transform/resource/after-ecj/LoggerSlf4jTypes.java index 74214cc4..25b3fd86 100644 --- a/test/transform/resource/after-ecj/LoggerSlf4jTypes.java +++ b/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); () { } Inner() { diff --git a/test/transform/resource/after-ecj/LoggerSlf4jWithClass.java b/test/transform/resource/after-ecj/LoggerSlf4jWithClass.java index 920f84e4..9f4846aa 100644 --- a/test/transform/resource/after-ecj/LoggerSlf4jWithClass.java +++ b/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); () { } LoggerSlf4jWithClassVoid() { diff --git a/test/transform/resource/after-ecj/LoggerSlf4jWithPackage.java b/test/transform/resource/after-ecj/LoggerSlf4jWithPackage.java index d56db764..655d14f8 100644 --- a/test/transform/resource/after-ecj/LoggerSlf4jWithPackage.java +++ b/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); () { } 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); () { } Inner() { diff --git a/test/transform/resource/before/LoggerSlf4jClassOfArray.java b/test/transform/resource/before/LoggerSlf4jClassOfArray.java index f18e11f0..87248538 100644 --- a/test/transform/resource/before/LoggerSlf4jClassOfArray.java +++ b/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 { +} diff --git a/website/features/Log.html b/website/features/Log.html index c63eeb05..6912b6ed 100644 --- a/website/features/Log.html +++ b/website/features/Log.html @@ -51,9 +51,6 @@

If a field called log already exists, a warning will be emitted and no code will be generated.

-

- Although it is possible to specify any class literal to pass to the logger factory method, passing void.class will be considered to be the same as specifying no parameter. -

-- cgit