diff options
36 files changed, 563 insertions, 9 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 @{@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 @{@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; +} diff --git a/test/transform/resource/after-delombok/LoggerSlf4j.java b/test/transform/resource/after-delombok/LoggerSlf4j.java index 0d7dee22..dae17826 100644 --- a/test/transform/resource/after-delombok/LoggerSlf4j.java +++ b/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); + } }
\ No newline at end of file diff --git a/test/transform/resource/after-delombok/LoggerSlf4jAlreadyExists.java b/test/transform/resource/after-delombok/LoggerSlf4jAlreadyExists.java new file mode 100644 index 00000000..a7cd9409 --- /dev/null +++ b/test/transform/resource/after-delombok/LoggerSlf4jAlreadyExists.java @@ -0,0 +1,3 @@ +class LoggerSlf4jAlreadyExists { + int log; +}
\ No newline at end of file diff --git a/test/transform/resource/after-delombok/LoggerSlf4jClassOfArray.java b/test/transform/resource/after-delombok/LoggerSlf4jClassOfArray.java new file mode 100644 index 00000000..bcae2741 --- /dev/null +++ b/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); +} diff --git a/test/transform/resource/after-delombok/LoggerSlf4jOnNonType.java b/test/transform/resource/after-delombok/LoggerSlf4jOnNonType.java new file mode 100644 index 00000000..4c944172 --- /dev/null +++ b/test/transform/resource/after-delombok/LoggerSlf4jOnNonType.java @@ -0,0 +1,4 @@ +class LoggerSlf4jOnNonType { + void foo() { + } +}
\ No newline at end of file diff --git a/test/transform/resource/after-delombok/LoggerSlf4jTypes.java b/test/transform/resource/after-delombok/LoggerSlf4jTypes.java new file mode 100644 index 00000000..539f46d6 --- /dev/null +++ b/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); + } +}
\ No newline at end of file diff --git a/test/transform/resource/after-delombok/LoggerSlf4jWithClass.java b/test/transform/resource/after-delombok/LoggerSlf4jWithClass.java new file mode 100644 index 00000000..5908d374 --- /dev/null +++ b/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); +} diff --git a/test/transform/resource/after-delombok/LoggerSlf4jWithPackage.java b/test/transform/resource/after-delombok/LoggerSlf4jWithPackage.java new file mode 100644 index 00000000..516f858f --- /dev/null +++ b/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); + } +} diff --git a/test/transform/resource/after-ecj/LoggerSlf4j.java b/test/transform/resource/after-ecj/LoggerSlf4j.java new file mode 100644 index 00000000..6a611c2b --- /dev/null +++ b/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(); + } +}
\ No newline at end of file diff --git a/test/transform/resource/after-ecj/LoggerSlf4jAlreadyExists.java b/test/transform/resource/after-ecj/LoggerSlf4jAlreadyExists.java new file mode 100644 index 00000000..60e83922 --- /dev/null +++ b/test/transform/resource/after-ecj/LoggerSlf4jAlreadyExists.java @@ -0,0 +1,6 @@ +@lombok.slf4j.Log class LoggerSlf4jAlreadyExists { + int log; + LoggerSlf4jAlreadyExists() { + super(); + } +}
\ No newline at end of file diff --git a/test/transform/resource/after-ecj/LoggerSlf4jClassOfArray.java b/test/transform/resource/after-ecj/LoggerSlf4jClassOfArray.java new file mode 100644 index 00000000..c8f8069d --- /dev/null +++ b/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(); + } +}
\ No newline at end of file diff --git a/test/transform/resource/after-ecj/LoggerSlf4jOnNonType.java b/test/transform/resource/after-ecj/LoggerSlf4jOnNonType.java new file mode 100644 index 00000000..83567493 --- /dev/null +++ b/test/transform/resource/after-ecj/LoggerSlf4jOnNonType.java @@ -0,0 +1,7 @@ +class LoggerSlf4jOnNonType { + LoggerSlf4jOnNonType() { + super(); + } + @lombok.slf4j.Log void foo() { + } +}
\ No newline at end of file diff --git a/test/transform/resource/after-ecj/LoggerSlf4jTypes.java b/test/transform/resource/after-ecj/LoggerSlf4jTypes.java new file mode 100644 index 00000000..88bcdae8 --- /dev/null +++ b/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(); + } + } +}
\ No newline at end of file diff --git a/test/transform/resource/after-ecj/LoggerSlf4jWithClass.java b/test/transform/resource/after-ecj/LoggerSlf4jWithClass.java new file mode 100644 index 00000000..2839cdef --- /dev/null +++ b/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(); + } +} diff --git a/test/transform/resource/after-ecj/LoggerSlf4jWithPackage.java b/test/transform/resource/after-ecj/LoggerSlf4jWithPackage.java new file mode 100644 index 00000000..efd43685 --- /dev/null +++ b/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(); + } +}
\ No newline at end of file diff --git a/test/transform/resource/before/LoggerSlf4j.java b/test/transform/resource/before/LoggerSlf4j.java new file mode 100644 index 00000000..78a33fe4 --- /dev/null +++ b/test/transform/resource/before/LoggerSlf4j.java @@ -0,0 +1,9 @@ +@lombok.slf4j.Log +class LoggerSlf4j { +} +class LoggerSlf4jOuter { + @lombok.slf4j.Log + static class Inner { + + } +}
\ No newline at end of file diff --git a/test/transform/resource/before/LoggerSlf4jAlreadyExists.java b/test/transform/resource/before/LoggerSlf4jAlreadyExists.java new file mode 100644 index 00000000..d0b26482 --- /dev/null +++ b/test/transform/resource/before/LoggerSlf4jAlreadyExists.java @@ -0,0 +1,4 @@ +@lombok.slf4j.Log +class LoggerSlf4jAlreadyExists { + int log; +}
\ No newline at end of file diff --git a/test/transform/resource/before/LoggerSlf4jClassOfArray.java b/test/transform/resource/before/LoggerSlf4jClassOfArray.java new file mode 100644 index 00000000..34394f13 --- /dev/null +++ b/test/transform/resource/before/LoggerSlf4jClassOfArray.java @@ -0,0 +1,3 @@ +@lombok.slf4j.Log(String[].class) +class LoggerSlf4jClassOfArray { +} diff --git a/test/transform/resource/before/LoggerSlf4jOnNonType.java b/test/transform/resource/before/LoggerSlf4jOnNonType.java new file mode 100644 index 00000000..06c8b059 --- /dev/null +++ b/test/transform/resource/before/LoggerSlf4jOnNonType.java @@ -0,0 +1,5 @@ +class LoggerSlf4jOnNonType { + @lombok.slf4j.Log + void foo() { + } +}
\ No newline at end of file diff --git a/test/transform/resource/before/LoggerSlf4jTypes.java b/test/transform/resource/before/LoggerSlf4jTypes.java new file mode 100644 index 00000000..27201090 --- /dev/null +++ b/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 { + } +}
\ No newline at end of file diff --git a/test/transform/resource/before/LoggerSlf4jWithClass.java b/test/transform/resource/before/LoggerSlf4jWithClass.java new file mode 100644 index 00000000..0005d1f5 --- /dev/null +++ b/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 { +} diff --git a/test/transform/resource/before/LoggerSlf4jWithPackage.java b/test/transform/resource/before/LoggerSlf4jWithPackage.java new file mode 100644 index 00000000..db6e8939 --- /dev/null +++ b/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 { + } +}
\ No newline at end of file diff --git a/test/transform/resource/messages-delombok/LoggerSlf4jAlreadyExists.java.messages b/test/transform/resource/messages-delombok/LoggerSlf4jAlreadyExists.java.messages new file mode 100644 index 00000000..ede6defa --- /dev/null +++ b/test/transform/resource/messages-delombok/LoggerSlf4jAlreadyExists.java.messages @@ -0,0 +1 @@ +1:1 WARNING Field 'log' already exists. diff --git a/test/transform/resource/messages-delombok/LoggerSlf4jOnNonStaticInnerClass.java.messages b/test/transform/resource/messages-delombok/LoggerSlf4jOnNonStaticInnerClass.java.messages new file mode 100644 index 00000000..e0bbdb2a --- /dev/null +++ b/test/transform/resource/messages-delombok/LoggerSlf4jOnNonStaticInnerClass.java.messages @@ -0,0 +1 @@ +2:9 ERROR @Log is not legal on non-static inner classes.
\ No newline at end of file diff --git a/test/transform/resource/messages-delombok/LoggerSlf4jOnNonType.java.messages b/test/transform/resource/messages-delombok/LoggerSlf4jOnNonType.java.messages new file mode 100644 index 00000000..9143d4bc --- /dev/null +++ b/test/transform/resource/messages-delombok/LoggerSlf4jOnNonType.java.messages @@ -0,0 +1 @@ +2:9 ERROR @Log is legal only on types.
\ No newline at end of file diff --git a/test/transform/resource/messages-delombok/LoggerSlf4jTypes.java.messages b/test/transform/resource/messages-delombok/LoggerSlf4jTypes.java.messages new file mode 100644 index 00000000..ba97e38f --- /dev/null +++ b/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.
\ No newline at end of file diff --git a/test/transform/resource/messages-ecj/LoggerSlf4jAlreadyExists.java.messages b/test/transform/resource/messages-ecj/LoggerSlf4jAlreadyExists.java.messages new file mode 100644 index 00000000..f03c7660 --- /dev/null +++ b/test/transform/resource/messages-ecj/LoggerSlf4jAlreadyExists.java.messages @@ -0,0 +1 @@ +1 warning Field 'log' already exists. diff --git a/test/transform/resource/messages-ecj/LoggerSlf4jOnNonStaticInnerClass.java.messages b/test/transform/resource/messages-ecj/LoggerSlf4jOnNonStaticInnerClass.java.messages new file mode 100644 index 00000000..e0bbdb2a --- /dev/null +++ b/test/transform/resource/messages-ecj/LoggerSlf4jOnNonStaticInnerClass.java.messages @@ -0,0 +1 @@ +2:9 ERROR @Log is not legal on non-static inner classes.
\ No newline at end of file diff --git a/test/transform/resource/messages-ecj/LoggerSlf4jOnNonType.java.messages b/test/transform/resource/messages-ecj/LoggerSlf4jOnNonType.java.messages new file mode 100644 index 00000000..4a446f28 --- /dev/null +++ b/test/transform/resource/messages-ecj/LoggerSlf4jOnNonType.java.messages @@ -0,0 +1 @@ +2 error @Log is legal only on types.
\ No newline at end of file diff --git a/test/transform/resource/messages-ecj/LoggerSlf4jTypes.java.messages b/test/transform/resource/messages-ecj/LoggerSlf4jTypes.java.messages new file mode 100644 index 00000000..42236c7c --- /dev/null +++ b/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.
\ No newline at end of file |