From 17bcfda43b9e939ac22d5247ef98905741650432 Mon Sep 17 00:00:00 2001 From: Roel Spilker Date: Tue, 2 Nov 2010 20:39:58 +0100 Subject: Issue 154: Add null-check to @Cleanup --- .../lombok/eclipse/handlers/HandleCleanup.java | 28 +++++++++++++++++++++- 1 file changed, 27 insertions(+), 1 deletion(-) (limited to 'src/core/lombok/eclipse') diff --git a/src/core/lombok/eclipse/handlers/HandleCleanup.java b/src/core/lombok/eclipse/handlers/HandleCleanup.java index d296e96b..33ab7fb9 100644 --- a/src/core/lombok/eclipse/handlers/HandleCleanup.java +++ b/src/core/lombok/eclipse/handlers/HandleCleanup.java @@ -37,9 +37,13 @@ import org.eclipse.jdt.internal.compiler.ast.Assignment; import org.eclipse.jdt.internal.compiler.ast.Block; import org.eclipse.jdt.internal.compiler.ast.CaseStatement; import org.eclipse.jdt.internal.compiler.ast.CastExpression; +import org.eclipse.jdt.internal.compiler.ast.EqualExpression; +import org.eclipse.jdt.internal.compiler.ast.IfStatement; import org.eclipse.jdt.internal.compiler.ast.LocalDeclaration; import org.eclipse.jdt.internal.compiler.ast.MemberValuePair; import org.eclipse.jdt.internal.compiler.ast.MessageSend; +import org.eclipse.jdt.internal.compiler.ast.NullLiteral; +import org.eclipse.jdt.internal.compiler.ast.OperatorIds; import org.eclipse.jdt.internal.compiler.ast.SingleNameReference; import org.eclipse.jdt.internal.compiler.ast.Statement; import org.eclipse.jdt.internal.compiler.ast.SwitchStatement; @@ -157,7 +161,29 @@ public class HandleCleanup implements EclipseAnnotationHandler { } unsafeClose.nameSourcePosition = nameSourcePosition; unsafeClose.selector = cleanupName.toCharArray(); - finallyBlock[0] = unsafeClose; + + + int pS = ast.sourceStart, pE = ast.sourceEnd; + long p = (long)pS << 32 | pE; + + SingleNameReference varName = new SingleNameReference(decl.name, p); + Eclipse.setGeneratedBy(varName, ast); + NullLiteral nullLiteral = new NullLiteral(pS, pE); + Eclipse.setGeneratedBy(nullLiteral, ast); + EqualExpression equalExpression = new EqualExpression(varName, nullLiteral, OperatorIds.NOT_EQUAL); + equalExpression.sourceStart = pS; equalExpression.sourceEnd = pE; + Eclipse.setGeneratedBy(equalExpression, ast); + + Block closeBlock = new Block(0); + closeBlock.statements = new Statement[1]; + closeBlock.statements[0] = unsafeClose; + Eclipse.setGeneratedBy(closeBlock, ast); + IfStatement ifStatement = new IfStatement(equalExpression, closeBlock, 0, 0); + Eclipse.setGeneratedBy(ifStatement, ast); + + + + finallyBlock[0] = ifStatement; tryStatement.finallyBlock = new Block(0); Eclipse.setGeneratedBy(tryStatement.finallyBlock, ast); tryStatement.finallyBlock.statements = finallyBlock; -- cgit From f6b60b0cae7f8af2e4598f2bbbd72839e193a36b Mon Sep 17 00:00:00 2001 From: Roel Spilker Date: Wed, 3 Nov 2010 02:13:28 +0100 Subject: Intial support for @Log, for now only slf4j --- .../eclipse/handlers/EclipseHandlerUtil.java | 10 +- .../lombok/eclipse/handlers/HandleSlf4jLog.java | 158 +++++++++++++++++++++ .../eclipse/handlers/HandleSynchronized.java | 2 +- 3 files changed, 168 insertions(+), 2 deletions(-) create mode 100644 src/core/lombok/eclipse/handlers/HandleSlf4jLog.java (limited to 'src/core/lombok/eclipse') 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 { + + @Override public boolean handle(AnnotationValues 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 Date: Sat, 6 Nov 2010 15:37:20 +0100 Subject: Add support for multiple logging frameworks in Eclipse --- src/core/lombok/eclipse/handlers/HandleLog.java | 267 +++++++++++++++++++++ .../lombok/eclipse/handlers/HandleSlf4jLog.java | 158 ------------ 2 files changed, 267 insertions(+), 158 deletions(-) create mode 100644 src/core/lombok/eclipse/handlers/HandleLog.java delete mode 100644 src/core/lombok/eclipse/handlers/HandleSlf4jLog.java (limited to 'src/core/lombok/eclipse') diff --git a/src/core/lombok/eclipse/handlers/HandleLog.java b/src/core/lombok/eclipse/handlers/HandleLog.java new file mode 100644 index 00000000..5991fec0 --- /dev/null +++ b/src/core/lombok/eclipse/handlers/HandleLog.java @@ -0,0 +1,267 @@ +/* + * 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 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.NameReference; +import org.eclipse.jdt.internal.compiler.ast.QualifiedNameReference; +import org.eclipse.jdt.internal.compiler.ast.QualifiedTypeReference; +import org.eclipse.jdt.internal.compiler.ast.StringLiteral; +import org.eclipse.jdt.internal.compiler.ast.TypeDeclaration; +import org.eclipse.jdt.internal.compiler.ast.TypeReference; +import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants; +import org.mangosdk.spi.ProviderFor; + +/** + * Handles the {@code lombok.HandleSneakyThrows} annotation for eclipse. + */ +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); + + 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; + } + + MemberExistsResult fieldExists = fieldExists("log", owner); + if (fieldExists != MemberExistsResult.NOT_EXISTS) { + annotationNode.addWarning("Field 'log' already exists."); + return true; + } + + if (loggingClassName.equals("void")) { + loggingClassName = getSelfName(owner); + } + + injectField(owner, createField(framework, source, loggingClassName)); + owner.rebuild(); + return true; + default: + annotationNode.addError("@Log is legal only on types."); + return true; + } + } + + 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) { + TypeDeclaration typeDeclaration = (TypeDeclaration)type.get(); + char[] rawTypeName = typeDeclaration.name; + return rawTypeName == null ? "" : new String(rawTypeName); + } + + private static FieldDeclaration createField(LoggingFramework framework, Annotation source, String loggingClassName) { + int pS = source.sourceStart, pE = source.sourceEnd; + long p = (long)pS << 32 | pE; + + // private static final log = (); + + 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 = createTypeReference(framework.getLoggerTypeName(), source); + + MessageSend factoryMethodCall = new MessageSend(); + Eclipse.setGeneratedBy(factoryMethodCall, source); + + factoryMethodCall.receiver = createNameReference(framework.getLoggerFactoryTypeName(), source); + factoryMethodCall.selector = framework.getLoggerFactoryMethodName().toCharArray(); + + Expression parameter = framework.createFactoryParameter(loggingClassName, source); + + factoryMethodCall.arguments = new Expression[] { parameter }; + factoryMethodCall.nameSourcePosition = p; + factoryMethodCall.sourceStart = pS; + factoryMethodCall.sourceEnd = factoryMethodCall.statementEnd = pE; + + fieldDecl.initialization = factoryMethodCall; + + return fieldDecl; + } + + private static TypeReference createTypeReference(String typeName, Annotation source) { + 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); + + QualifiedTypeReference typeReference = new QualifiedTypeReference(typeNameTokens, pos); + Eclipse.setGeneratedBy(typeReference, source); + return typeReference; + } + + private static NameReference createNameReference(String name, Annotation source) { + int pS = source.sourceStart, pE = source.sourceEnd; + long p = (long)pS << 32 | pE; + + char[][] nameTokens = fromQualifiedName(name); + long[] pos = new long[nameTokens.length]; + Arrays.fill(pos, p); + + QualifiedNameReference nameReference = new QualifiedNameReference(nameTokens, pos, pS, pE); + nameReference.statementEnd = pE; + + Eclipse.setGeneratedBy(nameReference, source); + return nameReference; + } + + /** + * Handles the {@link lombok.commons.Log} annotation for Eclipse. + */ + @ProviderFor(EclipseAnnotationHandler.class) + public static class HandleCommonsLog implements EclipseAnnotationHandler { + @Override public boolean handle(AnnotationValues annotation, Annotation source, EclipseNode annotationNode) { + return processAnnotation(LoggingFramework.COMMONS, annotation, source, annotationNode); + } + } + + /** + * Handles the {@link lombok.jul.Log} annotation for Eclipse. + */ + @ProviderFor(EclipseAnnotationHandler.class) + public static class HandleJulLog implements EclipseAnnotationHandler { + @Override public boolean handle(AnnotationValues annotation, Annotation source, EclipseNode annotationNode) { + return processAnnotation(LoggingFramework.JUL, annotation, source, annotationNode); + } + } + + /** + * Handles the {@link lombok.log4j.Log} annotation for Eclipse. + */ + @ProviderFor(EclipseAnnotationHandler.class) + public static class HandleLog4jLog implements EclipseAnnotationHandler { + @Override public boolean handle(AnnotationValues annotation, Annotation source, EclipseNode annotationNode) { + return processAnnotation(LoggingFramework.LOG4J, annotation, source, annotationNode); + } + } + + /** + * Handles the {@link lombok.slf4j.Log} annotation for Eclipse. + */ + @ProviderFor(EclipseAnnotationHandler.class) + public static class HandleSlf4jLog implements EclipseAnnotationHandler { + @Override public boolean handle(AnnotationValues annotation, Annotation source, EclipseNode annotationNode) { + return processAnnotation(LoggingFramework.SLF4J, annotation, source, annotationNode); + } + } + + enum LoggingFramework { + // private static final org.apache.commons.logging.Log log = org.apache.commons.logging.LogFactory.getLog(TargetType.class); + COMMONS(lombok.jul.Log.class, "org.apache.commons.logging.Log", "org.apache.commons.logging.LogFactory", "getLog"), + + // private static final java.util.logging.Logger log = java.util.logging.Logger.getLogger("TargetType"); + JUL(lombok.jul.Log.class, "java.util.logging.Logger", "java.util.logging.Logger", "getLogger") { + @Override public Expression createFactoryParameter(String typeName, Annotation source) { + Expression current = new StringLiteral(typeName.toCharArray(), source.sourceStart, source.sourceEnd, 0); + Eclipse.setGeneratedBy(current, source); + return current; + } + }, + + // private static final org.apache.log4j.Logger log = org.apache.log4j.Logger.getLogger(TargetType.class); + LOG4J(lombok.jul.Log.class, "org.apache.log4j.Logger", "org.apache.log4j.Logger", "getLogger"), + + // private static final org.slf4j.Logger log = org.slf4j.LoggerFactory.getLogger(TargetType.class); + SLF4J(lombok.slf4j.Log.class, "org.slf4j.Logger", "org.slf4j.LoggerFactory", "getLogger"), + + ; + + private final Class annotationClass; + private final String loggerTypeName; + private final String loggerFactoryTypeName; + private final String loggerFactoryMethodName; + + LoggingFramework(Class annotationClass, String loggerTypeName, String loggerFactoryTypeName, String loggerFactoryMethodName) { + this.annotationClass = annotationClass; + this.loggerTypeName = loggerTypeName; + this.loggerFactoryTypeName = loggerFactoryTypeName; + this.loggerFactoryMethodName = loggerFactoryMethodName; + } + + final Class getAnnotationClass() { + return annotationClass; + } + + final String getLoggerTypeName() { + return loggerTypeName; + } + + final String getLoggerFactoryTypeName() { + return loggerFactoryTypeName; + } + + final String getLoggerFactoryMethodName() { + return loggerFactoryMethodName; + } + + Expression createFactoryParameter(String typeName, Annotation source){ + return createNameReference(typeName + ".class", source); + }; + } +} diff --git a/src/core/lombok/eclipse/handlers/HandleSlf4jLog.java b/src/core/lombok/eclipse/handlers/HandleSlf4jLog.java deleted file mode 100644 index c9046260..00000000 --- a/src/core/lombok/eclipse/handlers/HandleSlf4jLog.java +++ /dev/null @@ -1,158 +0,0 @@ -/* - * 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 { - - @Override public boolean handle(AnnotationValues 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; - } -} -- cgit From a48c335c7d8f1b361b134110219af8b0d3610101 Mon Sep 17 00:00:00 2001 From: Roel Spilker Date: Sat, 6 Nov 2010 16:05:06 +0100 Subject: Code cleanup --- src/core/lombok/eclipse/handlers/HandleLog.java | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) (limited to 'src/core/lombok/eclipse') diff --git a/src/core/lombok/eclipse/handlers/HandleLog.java b/src/core/lombok/eclipse/handlers/HandleLog.java index 5991fec0..23768226 100644 --- a/src/core/lombok/eclipse/handlers/HandleLog.java +++ b/src/core/lombok/eclipse/handlers/HandleLog.java @@ -47,11 +47,12 @@ import org.eclipse.jdt.internal.compiler.ast.TypeReference; import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants; import org.mangosdk.spi.ProviderFor; -/** - * Handles the {@code lombok.HandleSneakyThrows} annotation for eclipse. - */ public class HandleLog { + private HandleLog() { + throw new UnsupportedOperationException(); + } + public static boolean processAnnotation(LoggingFramework framework, AnnotationValues annotation, Annotation source, EclipseNode annotationNode) { String loggingClassName = annotation.getRawExpression("value"); @@ -73,8 +74,7 @@ public class HandleLog { return false; } - MemberExistsResult fieldExists = fieldExists("log", owner); - if (fieldExists != MemberExistsResult.NOT_EXISTS) { + if (fieldExists("log", owner) != MemberExistsResult.NOT_EXISTS) { annotationNode.addWarning("Field 'log' already exists."); return true; } -- cgit From 0c7b29f8e7009d1433e2386f710c78801f119ebb Mon Sep 17 00:00:00 2001 From: Roel Spilker Date: Sat, 6 Nov 2010 16:41:17 +0100 Subject: Create Clinit if you create a static field and it doesn't yet exist --- .../lombok/eclipse/handlers/EclipseHandlerUtil.java | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) (limited to 'src/core/lombok/eclipse') diff --git a/src/core/lombok/eclipse/handlers/EclipseHandlerUtil.java b/src/core/lombok/eclipse/handlers/EclipseHandlerUtil.java index 29937279..c37de8ea 100644 --- a/src/core/lombok/eclipse/handlers/EclipseHandlerUtil.java +++ b/src/core/lombok/eclipse/handlers/EclipseHandlerUtil.java @@ -23,6 +23,7 @@ package lombok.eclipse.handlers; import static lombok.eclipse.Eclipse.*; +import java.lang.reflect.Modifier; import java.util.ArrayList; import java.util.Arrays; import java.util.List; @@ -42,6 +43,7 @@ import org.eclipse.jdt.internal.compiler.ast.AbstractMethodDeclaration; import org.eclipse.jdt.internal.compiler.ast.AbstractVariableDeclaration; import org.eclipse.jdt.internal.compiler.ast.AllocationExpression; import org.eclipse.jdt.internal.compiler.ast.Annotation; +import org.eclipse.jdt.internal.compiler.ast.Clinit; import org.eclipse.jdt.internal.compiler.ast.ConstructorDeclaration; import org.eclipse.jdt.internal.compiler.ast.EqualExpression; import org.eclipse.jdt.internal.compiler.ast.Expression; @@ -429,9 +431,24 @@ public class EclipseHandlerUtil { parent.fields = newArray; } + if ((field.modifiers & Modifier.STATIC) != 0) { + if (!hasClinit(parent)) { + parent.addClinit(); + } + } + type.add(field, Kind.FIELD).recursiveSetHandled(); } + private static boolean hasClinit(TypeDeclaration parent) { + if (parent.methods == null) return false; + + for (AbstractMethodDeclaration method : parent.methods) { + if (method instanceof Clinit) return true; + } + return false; + } + /** * Inserts a method into an existing type. The type must represent a {@code TypeDeclaration}. */ -- cgit From 529a480ca998f7eab16ff9745e8fb08aa28072e5 Mon Sep 17 00:00:00 2001 From: Roel Spilker Date: Sat, 6 Nov 2010 17:39:04 +0100 Subject: Use a ClassLiteralAccess instead of a NameReference --- src/core/lombok/eclipse/handlers/HandleLog.java | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) (limited to 'src/core/lombok/eclipse') diff --git a/src/core/lombok/eclipse/handlers/HandleLog.java b/src/core/lombok/eclipse/handlers/HandleLog.java index 23768226..08f3e6f2 100644 --- a/src/core/lombok/eclipse/handlers/HandleLog.java +++ b/src/core/lombok/eclipse/handlers/HandleLog.java @@ -35,6 +35,7 @@ import lombok.eclipse.EclipseNode; import lombok.eclipse.handlers.EclipseHandlerUtil.MemberExistsResult; import org.eclipse.jdt.internal.compiler.ast.Annotation; +import org.eclipse.jdt.internal.compiler.ast.ClassLiteralAccess; import org.eclipse.jdt.internal.compiler.ast.Expression; import org.eclipse.jdt.internal.compiler.ast.FieldDeclaration; import org.eclipse.jdt.internal.compiler.ast.MessageSend; @@ -261,7 +262,10 @@ public class HandleLog { } Expression createFactoryParameter(String typeName, Annotation source){ - return createNameReference(typeName + ".class", source); + TypeReference type = createTypeReference(typeName, source); + ClassLiteralAccess result = new ClassLiteralAccess(source.sourceEnd, type); + Eclipse.setGeneratedBy(result, source); + return result; }; } } -- cgit From 59150328992339ec64ae015e2d1d73c109c4d322 Mon Sep 17 00:00:00 2001 From: Roel Spilker Date: Sat, 6 Nov 2010 20:41:36 +0100 Subject: Have j.u.l. be invoked with TargetType.class.getName() instead of "TargetType" --- src/core/lombok/eclipse/handlers/HandleLog.java | 20 +++++++++++++++----- 1 file changed, 15 insertions(+), 5 deletions(-) (limited to 'src/core/lombok/eclipse') diff --git a/src/core/lombok/eclipse/handlers/HandleLog.java b/src/core/lombok/eclipse/handlers/HandleLog.java index 08f3e6f2..dfb45a29 100644 --- a/src/core/lombok/eclipse/handlers/HandleLog.java +++ b/src/core/lombok/eclipse/handlers/HandleLog.java @@ -42,7 +42,6 @@ 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.StringLiteral; import org.eclipse.jdt.internal.compiler.ast.TypeDeclaration; import org.eclipse.jdt.internal.compiler.ast.TypeReference; import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants; @@ -216,12 +215,23 @@ public class HandleLog { // private static final org.apache.commons.logging.Log log = org.apache.commons.logging.LogFactory.getLog(TargetType.class); COMMONS(lombok.jul.Log.class, "org.apache.commons.logging.Log", "org.apache.commons.logging.LogFactory", "getLog"), - // private static final java.util.logging.Logger log = java.util.logging.Logger.getLogger("TargetType"); + // private static final java.util.logging.Logger log = java.util.logging.Logger.getLogger(TargetType.class.getName()); JUL(lombok.jul.Log.class, "java.util.logging.Logger", "java.util.logging.Logger", "getLogger") { @Override public Expression createFactoryParameter(String typeName, Annotation source) { - Expression current = new StringLiteral(typeName.toCharArray(), source.sourceStart, source.sourceEnd, 0); - Eclipse.setGeneratedBy(current, source); - return current; + 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.selector = "getName".toCharArray(); + + factoryParameterCall.nameSourcePosition = p; + factoryParameterCall.sourceStart = pS; + factoryParameterCall.sourceEnd = factoryParameterCall.statementEnd = pE; + + return factoryParameterCall; } }, -- cgit 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/eclipse/handlers/HandleLog.java | 32 ++++++++++++------------- 1 file changed, 16 insertions(+), 16 deletions(-) (limited to 'src/core/lombok/eclipse') diff --git a/src/core/lombok/eclipse/handlers/HandleLog.java b/src/core/lombok/eclipse/handlers/HandleLog.java index dfb45a29..ad0ad200 100644 --- a/src/core/lombok/eclipse/handlers/HandleLog.java +++ b/src/core/lombok/eclipse/handlers/HandleLog.java @@ -172,51 +172,51 @@ public class HandleLog { } /** - * Handles the {@link lombok.commons.Log} annotation for Eclipse. + * Handles the {@link lombok.extern.apachecommons.Log} annotation for Eclipse. */ @ProviderFor(EclipseAnnotationHandler.class) - public static class HandleCommonsLog implements EclipseAnnotationHandler { - @Override public boolean handle(AnnotationValues annotation, Annotation source, EclipseNode annotationNode) { + public static class HandleCommonsLog implements EclipseAnnotationHandler { + @Override public boolean handle(AnnotationValues annotation, Annotation source, EclipseNode annotationNode) { return processAnnotation(LoggingFramework.COMMONS, annotation, source, annotationNode); } } /** - * Handles the {@link lombok.jul.Log} annotation for Eclipse. + * Handles the {@link lombok.extern.jul.Log} annotation for Eclipse. */ @ProviderFor(EclipseAnnotationHandler.class) - public static class HandleJulLog implements EclipseAnnotationHandler { - @Override public boolean handle(AnnotationValues annotation, Annotation source, EclipseNode annotationNode) { + public static class HandleJulLog implements EclipseAnnotationHandler { + @Override public boolean handle(AnnotationValues annotation, Annotation source, EclipseNode annotationNode) { return processAnnotation(LoggingFramework.JUL, annotation, source, annotationNode); } } /** - * Handles the {@link lombok.log4j.Log} annotation for Eclipse. + * Handles the {@link lombok.extern.log4j.Log} annotation for Eclipse. */ @ProviderFor(EclipseAnnotationHandler.class) - public static class HandleLog4jLog implements EclipseAnnotationHandler { - @Override public boolean handle(AnnotationValues annotation, Annotation source, EclipseNode annotationNode) { + public static class HandleLog4jLog implements EclipseAnnotationHandler { + @Override public boolean handle(AnnotationValues annotation, Annotation source, EclipseNode annotationNode) { return processAnnotation(LoggingFramework.LOG4J, annotation, source, annotationNode); } } /** - * Handles the {@link lombok.slf4j.Log} annotation for Eclipse. + * Handles the {@link lombok.extern.slf4j.Log} annotation for Eclipse. */ @ProviderFor(EclipseAnnotationHandler.class) - public static class HandleSlf4jLog implements EclipseAnnotationHandler { - @Override public boolean handle(AnnotationValues annotation, Annotation source, EclipseNode annotationNode) { + public static class HandleSlf4jLog implements EclipseAnnotationHandler { + @Override public boolean handle(AnnotationValues annotation, Annotation source, EclipseNode annotationNode) { return processAnnotation(LoggingFramework.SLF4J, annotation, source, annotationNode); } } enum LoggingFramework { // private static final org.apache.commons.logging.Log log = org.apache.commons.logging.LogFactory.getLog(TargetType.class); - COMMONS(lombok.jul.Log.class, "org.apache.commons.logging.Log", "org.apache.commons.logging.LogFactory", "getLog"), + COMMONS(lombok.extern.jul.Log.class, "org.apache.commons.logging.Log", "org.apache.commons.logging.LogFactory", "getLog"), // private static final java.util.logging.Logger log = java.util.logging.Logger.getLogger(TargetType.class.getName()); - JUL(lombok.jul.Log.class, "java.util.logging.Logger", "java.util.logging.Logger", "getLogger") { + JUL(lombok.extern.jul.Log.class, "java.util.logging.Logger", "java.util.logging.Logger", "getLogger") { @Override public Expression createFactoryParameter(String typeName, Annotation source) { int pS = source.sourceStart, pE = source.sourceEnd; long p = (long)pS << 32 | pE; @@ -236,10 +236,10 @@ public class HandleLog { }, // private static final org.apache.log4j.Logger log = org.apache.log4j.Logger.getLogger(TargetType.class); - LOG4J(lombok.jul.Log.class, "org.apache.log4j.Logger", "org.apache.log4j.Logger", "getLogger"), + LOG4J(lombok.extern.jul.Log.class, "org.apache.log4j.Logger", "org.apache.log4j.Logger", "getLogger"), // private static final org.slf4j.Logger log = org.slf4j.LoggerFactory.getLogger(TargetType.class); - SLF4J(lombok.slf4j.Log.class, "org.slf4j.Logger", "org.slf4j.LoggerFactory", "getLogger"), + SLF4J(lombok.extern.slf4j.Log.class, "org.slf4j.Logger", "org.slf4j.LoggerFactory", "getLogger"), ; -- cgit From 50524f338ef1f29a1848a2f2d542d6b7317c5eff Mon Sep 17 00:00:00 2001 From: Roel Spilker Date: Sun, 7 Nov 2010 02:48:13 +0100 Subject: Provide access to the actual annotation values --- src/core/lombok/eclipse/Eclipse.java | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) (limited to 'src/core/lombok/eclipse') diff --git a/src/core/lombok/eclipse/Eclipse.java b/src/core/lombok/eclipse/Eclipse.java index c70660f4..915706f9 100644 --- a/src/core/lombok/eclipse/Eclipse.java +++ b/src/core/lombok/eclipse/Eclipse.java @@ -377,6 +377,7 @@ public class Eclipse { if (!Modifier.isPublic(m.getModifiers())) continue; String name = m.getName(); List raws = new ArrayList(); + List expressionValues = new ArrayList(); List guesses = new ArrayList(); Expression fullExpression = null; Expression[] expressions = null; @@ -397,6 +398,7 @@ public class Eclipse { StringBuffer sb = new StringBuffer(); ex.print(0, sb); raws.add(sb.toString()); + expressionValues.add(ex); guesses.add(calculateValue(ex)); } } @@ -404,7 +406,7 @@ public class Eclipse { final Expression fullExpr = fullExpression; final Expression[] exprs = expressions; - values.put(name, new AnnotationValue(annotationNode, raws, guesses, isExplicit) { + values.put(name, new AnnotationValue(annotationNode, raws, expressionValues, guesses, isExplicit) { @Override public void setError(String message, int valueIdx) { Expression ex; if (valueIdx == -1) ex = fullExpr; -- 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 +++++++++++++------------ 1 file changed, 39 insertions(+), 36 deletions(-) (limited to 'src/core/lombok/eclipse') 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; }; -- cgit From 378b939108ef2216da00724a8efd9521b7a10b8f Mon Sep 17 00:00:00 2001 From: Roel Spilker Date: Sun, 7 Nov 2010 15:13:47 +0100 Subject: Now generated nodes can also be detected in ecj --- src/core/lombok/eclipse/Eclipse.java | 28 ++++++++++++++++++---------- 1 file changed, 18 insertions(+), 10 deletions(-) (limited to 'src/core/lombok/eclipse') diff --git a/src/core/lombok/eclipse/Eclipse.java b/src/core/lombok/eclipse/Eclipse.java index 915706f9..659651d6 100644 --- a/src/core/lombok/eclipse/Eclipse.java +++ b/src/core/lombok/eclipse/Eclipse.java @@ -29,6 +29,7 @@ import java.util.Collection; import java.util.HashMap; import java.util.List; import java.util.Map; +import java.util.WeakHashMap; import lombok.core.AnnotationValues; import lombok.core.TypeLibrary; @@ -476,12 +477,16 @@ public class Eclipse { } } + private static Map generatedNodes = new WeakHashMap(); + public static ASTNode getGeneratedBy(ASTNode node) { - try { - return (ASTNode) generatedByField.get(node); - } catch (Exception t) { - //ignore - no $generatedBy exists when running in ecj. - return null; + if (generatedByField != null) { + try { + return (ASTNode) generatedByField.get(node); + } catch (Exception e) {} + } + synchronized (generatedNodes) { + return generatedNodes.get(node); } } @@ -490,12 +495,15 @@ public class Eclipse { } public static ASTNode setGeneratedBy(ASTNode node, ASTNode source) { - try { - generatedByField.set(node, source); - } catch (Exception t) { - //ignore - no $generatedBy exists when running in ecj. + if (generatedByField != null) { + try { + generatedByField.set(node, source); + return node; + } catch (Exception e) {} + } + synchronized (generatedNodes) { + generatedNodes.put(node, source); } - return node; } } -- cgit From 2097dd87310026733a4f48c47bb31a59996f5d83 Mon Sep 17 00:00:00 2001 From: Roel Spilker Date: Sun, 7 Nov 2010 15:16:48 +0100 Subject: Solved issue 155: "Eclipse constructor generation not in class body" http://code.google.com/p/projectlombok/issues/detail?id=155 Now all lombok generated methods are located before any other method. --- .../eclipse/handlers/EclipseHandlerUtil.java | 33 ++++++++++++++++------ 1 file changed, 25 insertions(+), 8 deletions(-) (limited to 'src/core/lombok/eclipse') diff --git a/src/core/lombok/eclipse/handlers/EclipseHandlerUtil.java b/src/core/lombok/eclipse/handlers/EclipseHandlerUtil.java index c37de8ea..019ae637 100644 --- a/src/core/lombok/eclipse/handlers/EclipseHandlerUtil.java +++ b/src/core/lombok/eclipse/handlers/EclipseHandlerUtil.java @@ -460,25 +460,42 @@ public class EclipseHandlerUtil { parent.methods = new AbstractMethodDeclaration[1]; parent.methods[0] = method; } else { - boolean injectionComplete = false; if (method instanceof ConstructorDeclaration) { for (int i = 0 ; i < parent.methods.length ; i++) { if (parent.methods[i] instanceof ConstructorDeclaration && (parent.methods[i].bits & ASTNode.IsDefaultConstructor) != 0) { EclipseNode tossMe = type.getNodeFor(parent.methods[i]); - parent.methods[i] = method; + + AbstractMethodDeclaration[] withoutGeneratedConstructor = new AbstractMethodDeclaration[parent.methods.length - 1]; + + System.arraycopy(parent.methods, 0, withoutGeneratedConstructor, 0, i); + System.arraycopy(parent.methods, i + 1, withoutGeneratedConstructor, i, parent.methods.length - i - 1); + + parent.methods = withoutGeneratedConstructor; if (tossMe != null) tossMe.up().removeChild(tossMe); - injectionComplete = true; break; } } } - if (!injectionComplete) { - AbstractMethodDeclaration[] newArray = new AbstractMethodDeclaration[parent.methods.length + 1]; - System.arraycopy(parent.methods, 0, newArray, 0, parent.methods.length); - newArray[parent.methods.length] = method; - parent.methods = newArray; + int insertionPoint; + for (insertionPoint = 0; insertionPoint < parent.methods.length; insertionPoint++) { + AbstractMethodDeclaration current = parent.methods[insertionPoint]; + if (current instanceof Clinit) continue; + if (method instanceof ConstructorDeclaration) { + if (current instanceof ConstructorDeclaration) continue; + break; + } + if (Eclipse.isGenerated(current)) continue; + break; + } + AbstractMethodDeclaration[] newArray = new AbstractMethodDeclaration[parent.methods.length + 1]; + System.arraycopy(parent.methods, 0, newArray, 0, insertionPoint); + if (insertionPoint <= parent.methods.length) { + System.arraycopy(parent.methods, insertionPoint, newArray, insertionPoint + 1, parent.methods.length - insertionPoint); } + + newArray[insertionPoint] = method; + parent.methods = newArray; } type.add(method, Kind.METHOD).recursiveSetHandled(); -- cgit From 3b58e1a11539a6da05fa25f51e2acd91d2d9f7d7 Mon Sep 17 00:00:00 2001 From: Reinier Zwitserloot Date: Sun, 7 Nov 2010 23:23:48 +0100 Subject: 'val' support for eclipse. --- src/core/lombok/eclipse/Eclipse.java | 140 +++++++++++++++++++++++- src/core/lombok/eclipse/handlers/HandleVal.java | 53 +++++++++ 2 files changed, 192 insertions(+), 1 deletion(-) create mode 100644 src/core/lombok/eclipse/handlers/HandleVal.java (limited to 'src/core/lombok/eclipse') diff --git a/src/core/lombok/eclipse/Eclipse.java b/src/core/lombok/eclipse/Eclipse.java index c70660f4..ac8505af 100644 --- a/src/core/lombok/eclipse/Eclipse.java +++ b/src/core/lombok/eclipse/Eclipse.java @@ -25,6 +25,7 @@ import java.lang.reflect.Field; import java.lang.reflect.Method; import java.lang.reflect.Modifier; import java.util.ArrayList; +import java.util.Arrays; import java.util.Collection; import java.util.HashMap; import java.util.List; @@ -62,7 +63,13 @@ import org.eclipse.jdt.internal.compiler.ast.SingleTypeReference; import org.eclipse.jdt.internal.compiler.ast.TypeParameter; import org.eclipse.jdt.internal.compiler.ast.TypeReference; import org.eclipse.jdt.internal.compiler.ast.Wildcard; +import org.eclipse.jdt.internal.compiler.lookup.CaptureBinding; +import org.eclipse.jdt.internal.compiler.lookup.ParameterizedTypeBinding; +import org.eclipse.jdt.internal.compiler.lookup.ReferenceBinding; +import org.eclipse.jdt.internal.compiler.lookup.TypeBinding; +import org.eclipse.jdt.internal.compiler.lookup.TypeConstants; import org.eclipse.jdt.internal.compiler.lookup.TypeIds; +import org.eclipse.jdt.internal.compiler.lookup.WildcardBinding; import org.osgi.framework.Bundle; public class Eclipse { @@ -156,7 +163,6 @@ public class Eclipse { return result; } - /** * You can't share TypeParameter objects or bad things happen; for example, one 'T' resolves differently * from another 'T', even for the same T in a single class file. Unfortunately the TypeParameter type hierarchy @@ -292,6 +298,138 @@ public class Eclipse { return ref; } + private static long pos(ASTNode node) { + return ((long) node.sourceStart << 32) | (node.sourceEnd & 0xFFFFFFFFL); + } + + public static long[] poss(ASTNode node, int repeat) { + long p = ((long) node.sourceStart << 32) | (node.sourceEnd & 0xFFFFFFFFL); + long[] out = new long[repeat]; + Arrays.fill(out, p); + return out; + } + + public static TypeReference makeType(TypeBinding binding, ASTNode pos, boolean allowCompound) { + // Primitives + switch (binding.id) { + case TypeIds.T_int: + return new SingleTypeReference(TypeConstants.INT, pos(pos)); + case TypeIds.T_long: + return new SingleTypeReference(TypeConstants.LONG, pos(pos)); + case TypeIds.T_short: + return new SingleTypeReference(TypeConstants.SHORT, pos(pos)); + case TypeIds.T_byte: + return new SingleTypeReference(TypeConstants.BYTE, pos(pos)); + case TypeIds.T_double: + return new SingleTypeReference(TypeConstants.DOUBLE, pos(pos)); + case TypeIds.T_float: + return new SingleTypeReference(TypeConstants.FLOAT, pos(pos)); + case TypeIds.T_boolean: + return new SingleTypeReference(TypeConstants.BOOLEAN, pos(pos)); + case TypeIds.T_void: + return new SingleTypeReference(TypeConstants.VOID, pos(pos)); + case TypeIds.T_char: + return new SingleTypeReference(TypeConstants.CHAR, pos(pos)); + case TypeIds.T_null: + return null; + } + + if (binding.isAnonymousType()) { + ReferenceBinding ref = (ReferenceBinding)binding; + ReferenceBinding[] supers = ref.superInterfaces(); + if (supers == null || supers.length == 0) supers = new ReferenceBinding[] {ref.superclass()}; + if (supers[0] == null) return new QualifiedTypeReference(TypeConstants.JAVA_LANG_OBJECT, poss(pos, 3)); + return makeType(supers[0], pos, false); + } + + if (binding instanceof CaptureBinding) { + return makeType(((CaptureBinding)binding).wildcard, pos, allowCompound); + } + + if (binding.isUnboundWildcard()) { + if (!allowCompound) { + return new QualifiedTypeReference(TypeConstants.JAVA_LANG_OBJECT, poss(pos, 3)); + } else { + Wildcard out = new Wildcard(Wildcard.UNBOUND); + out.sourceStart = pos.sourceStart; + out.sourceEnd = pos.sourceEnd; + return out; + } + } + + if (binding.isWildcard()) { + WildcardBinding wildcard = (WildcardBinding) binding; + if (wildcard.boundKind == Wildcard.EXTENDS) { + if (!allowCompound) { + return makeType(wildcard.bound, pos, false); + } else { + Wildcard out = new Wildcard(Wildcard.EXTENDS); + out.bound = makeType(wildcard.bound, pos, false); + out.sourceStart = pos.sourceStart; + out.sourceEnd = pos.sourceEnd; + return out; + } + } else if (allowCompound && wildcard.boundKind == Wildcard.SUPER) { + Wildcard out = new Wildcard(Wildcard.SUPER); + out.bound = makeType(wildcard.bound, pos, false); + out.sourceStart = pos.sourceStart; + out.sourceEnd = pos.sourceEnd; + return out; + } else { + return new QualifiedTypeReference(TypeConstants.JAVA_LANG_OBJECT, poss(pos, 3)); + } + } + + char[][] parts; + + if (binding.isLocalType() || binding.isTypeVariable()) { + parts = new char[][] { binding.shortReadableName() }; + } else { + String[] pkg = new String(binding.qualifiedPackageName()).split("\\."); + String[] name = new String(binding.qualifiedSourceName()).split("\\."); + parts = new char[pkg.length + name.length][]; + int ptr; + for (ptr = 0; ptr < pkg.length; ptr++) parts[ptr] = pkg[ptr].toCharArray(); + for (; ptr < pkg.length + name.length; ptr++) parts[ptr] = name[ptr - pkg.length].toCharArray(); + } + + TypeReference[] params = new TypeReference[0]; + + if (binding instanceof ParameterizedTypeBinding) { + ParameterizedTypeBinding paramized = (ParameterizedTypeBinding) binding; + if (paramized.arguments != null) { + params = new TypeReference[paramized.arguments.length]; + for (int i = 0; i < params.length; i++) { + params[i] = makeType(paramized.arguments[i], pos, true); + } + } + } + + int dims = binding.dimensions(); + + if (params.length > 0) { + if (parts.length > 1) { + TypeReference[][] typeArguments = new TypeReference[parts.length][]; + typeArguments[typeArguments.length - 1] = params; + return new ParameterizedQualifiedTypeReference(parts, typeArguments, dims, poss(pos, parts.length)); + } + return new ParameterizedSingleTypeReference(parts[0], params, dims, pos(pos)); + } + + if (dims > 0) { + if (parts.length > 1) { + return new ArrayQualifiedTypeReference(parts, dims, poss(pos, parts.length)); + } + return new ArrayTypeReference(parts[0], dims, pos(pos)); + } + + if (parts.length > 1) { + return new QualifiedTypeReference(parts, poss(pos, parts.length)); + } + return new SingleTypeReference(parts[0], pos(pos)); + + } + public static Annotation[] copyAnnotations(Annotation[] annotations, ASTNode source) { return copyAnnotations(annotations, null, source); } diff --git a/src/core/lombok/eclipse/handlers/HandleVal.java b/src/core/lombok/eclipse/handlers/HandleVal.java new file mode 100644 index 00000000..6fa39b10 --- /dev/null +++ b/src/core/lombok/eclipse/handlers/HandleVal.java @@ -0,0 +1,53 @@ +/* + * Copyright © 2009-2010 Reinier Zwitserloot, Roel Spilker and Robbert Jan Grootjans. + *