tiennm99/lombok
1
0 Fork 0
mirror of https://github.com/tiennm99/lombok.git synced 2026-10-14 12:16:49 +00:00
Code Issues Packages Projects Releases Wiki Activity

Added support for @ToString annotation. The code for generating toStrings has now moved from HandleData to the new HandleToString.

Browse Source
This commit is contained in:
Reinier Zwitserloot committed 2009-07-27 09:21:22 +02:00
1 parent 3e03dcfac1
commit d906899546
5 files changed
+494 -102
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

src/lombok/ToString.java
+57
View File
@@ -0,0 +1,57 @@
/*
* Copyright © 2009 Reinier Zwitserloot and Roel Spilker.
*
* 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;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* Generates an implementation for the <code>toString</code> method inherited by all objects.
* <p>
* If the method already exists, then <code>&#64;ToString</code> will not generate any method, and instead warns
* that it's doing nothing at all. The parameter list and return type are not relevant when deciding to skip generation of
* the method; any method named <code>toString</code> will make <code>&#64;ToString</code> not generate anything.
* <p>
* All fields that are non-static are used in the toString generation. You can exclude fields by specifying them
* in the <code>exclude</code> parameter.
* <p>
* Array fields are handled by way of {@link java.util.Arrays#deepToString(Object[], Object[])} where necessary.
* The downside is that arrays with circular references (arrays that contain themselves,
* possibly indirectly) results in calls to <code>toString</code> throwing a
* {@link java.lang.StackOverflowError}. However, the implementations for java's own {@link java.util.ArrayList} suffer
* from the same flaw.
* <p>
* The <code>toString</code> method that is generated will print the class name as well as each field. You can optionally
* also print the names of each field, by setting the <code>includeFieldNames</code> flag to <em>true</em>.
* <p>
* You can also choose to include the result of <code>toString</code> in your class's superclass by setting the
* <code>callSuper</code> to <em>true</em>.
*/
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.SOURCE)
public @interface ToString {
boolean includeFieldNames() default false;
boolean callSuper() default false;
String[] exclude() default {};
}
src/lombok/eclipse/handlers/HandleData.java
+1 -62
View File
@@ -75,7 +75,6 @@ import org.eclipse.jdt.internal.compiler.ast.ReturnStatement;
import org.eclipse.jdt.internal.compiler.ast.SingleNameReference;
import org.eclipse.jdt.internal.compiler.ast.SingleTypeReference;
import org.eclipse.jdt.internal.compiler.ast.Statement;
import org.eclipse.jdt.internal.compiler.ast.StringLiteral;
import org.eclipse.jdt.internal.compiler.ast.ThisReference;
import org.eclipse.jdt.internal.compiler.ast.TrueLiteral;
import org.eclipse.jdt.internal.compiler.ast.TypeDeclaration;
@@ -110,7 +109,6 @@ public class HandleData implements EclipseAnnotationHandler<Data> {
List<Node> nodesForEquality = new ArrayList<Node>();
List<Node> nodesForConstructor = new ArrayList<Node>();
List<Node> nodesForToString = new ArrayList<Node>();
for ( Node child : typeNode.down() ) {
if ( child.getKind() != Kind.FIELD ) continue;
FieldDeclaration fieldDecl = (FieldDeclaration) child.get();
@@ -118,16 +116,12 @@ public class HandleData implements EclipseAnnotationHandler<Data> {
if ( (fieldDecl.modifiers & ClassFileConstants.AccStatic) != 0 ) continue;
if ( (fieldDecl.modifiers & ClassFileConstants.AccTransient) == 0 ) nodesForEquality.add(child);
boolean isFinal = (fieldDecl.modifiers & ClassFileConstants.AccFinal) != 0;
nodesForToString.add(child);
if ( isFinal && fieldDecl.initialization == null ) nodesForConstructor.add(child);
new HandleGetter().generateGetterForField(child, annotationNode.get());
if ( !isFinal ) new HandleSetter().generateSetterForField(child, annotationNode.get());
}
if ( methodExists("toString", typeNode) == MemberExistsResult.NOT_EXISTS ) {
MethodDeclaration toString = createToString(typeNode, nodesForToString, ast);
injectMethod(typeNode, toString);
}
new HandleToString().generateToStringForType(typeNode, annotationNode);
if ( methodExists("equals", typeNode) == MemberExistsResult.NOT_EXISTS ) {
MethodDeclaration equals = createEquals(typeNode, nodesForEquality, ast);
@@ -162,61 +156,6 @@ public class HandleData implements EclipseAnnotationHandler<Data> {
return false;
}
private MethodDeclaration createToString(Node type, Collection<Node> fields, ASTNode pos) {
char[] rawTypeName = ((TypeDeclaration)type.get()).name;
String typeName = rawTypeName == null ? "" : new String(rawTypeName);
char[] prefix = (typeName + "(").toCharArray();
char[] suffix = ")".toCharArray();
char[] infix = ", ".toCharArray();
long p = (long)pos.sourceStart << 32 | pos.sourceEnd;
final int PLUS = OperatorIds.PLUS;
boolean first = true;
Expression current = new StringLiteral(prefix, 0, 0, 0);
for ( Node field : fields ) {
FieldDeclaration f = (FieldDeclaration)field.get();
if ( f.name == null || f.type == null ) continue;
if ( !first ) {
current = new BinaryExpression(current, new StringLiteral(infix, 0, 0, 0), PLUS);
}
else first = false;
Expression ex;
if ( f.type.dimensions() > 0 ) {
MessageSend arrayToString = new MessageSend();
arrayToString.receiver = generateQualifiedNameRef(TypeConstants.JAVA, TypeConstants.UTIL, "Arrays".toCharArray());
arrayToString.arguments = new Expression[] { new SingleNameReference(f.name, p) };
if ( f.type.dimensions() > 1 || !BUILT_IN_TYPES.contains(new String(f.type.getLastToken())) ) {
arrayToString.selector = "deepToString".toCharArray();
} else {
arrayToString.selector = "toString".toCharArray();
}
ex = arrayToString;
} else ex = new SingleNameReference(f.name, p);
current = new BinaryExpression(current, ex, PLUS);
}
current = new BinaryExpression(current, new StringLiteral(suffix, 0, 0, 0), PLUS);
ReturnStatement returnStatement = new ReturnStatement(current, (int)(p >> 32), (int)p);
MethodDeclaration method = new MethodDeclaration(((CompilationUnitDeclaration) type.top().get()).compilationResult);
method.modifiers = PKG.toModifier(AccessLevel.PUBLIC);
method.returnType = new QualifiedTypeReference(TypeConstants.JAVA_LANG_STRING, new long[] {0, 0, 0});
method.annotations = new Annotation[] {
new MarkerAnnotation(new QualifiedTypeReference(TypeConstants.JAVA_LANG_OVERRIDE, new long[] { 0, 0, 0}), 0)
};
method.arguments = null;
method.selector = "toString".toCharArray();
method.thrownExceptions = null;
method.typeParameters = null;
method.bits |= Eclipse.ECLIPSE_DO_NOT_TOUCH_FLAG;
method.bodyStart = method.declarationSourceStart = method.sourceStart = pos.sourceStart;
method.bodyEnd = method.declarationSourceEnd = method.sourceEnd = pos.sourceEnd;
method.statements = new Statement[] { returnStatement };
return method;
}
private ConstructorDeclaration createConstructor(boolean isPublic, Node type, Collection<Node> fields, ASTNode pos) {
long p = (long)pos.sourceStart << 32 | pos.sourceEnd;
src/lombok/eclipse/handlers/HandleToString.java
+238
View File
@@ -0,0 +1,238 @@
/*
* Copyright © 2009 Reinier Zwitserloot and Roel Spilker.
*
* 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.handlers.PKG.*;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import lombok.AccessLevel;
import lombok.ToString;
import lombok.core.AnnotationValues;
import lombok.core.AST.Kind;
import lombok.eclipse.Eclipse;
import lombok.eclipse.EclipseAnnotationHandler;
import lombok.eclipse.EclipseAST.Node;
import org.eclipse.jdt.internal.compiler.ast.ASTNode;
import org.eclipse.jdt.internal.compiler.ast.Annotation;
import org.eclipse.jdt.internal.compiler.ast.BinaryExpression;
import org.eclipse.jdt.internal.compiler.ast.CompilationUnitDeclaration;
import org.eclipse.jdt.internal.compiler.ast.Expression;
import org.eclipse.jdt.internal.compiler.ast.FieldDeclaration;
import org.eclipse.jdt.internal.compiler.ast.MarkerAnnotation;
import org.eclipse.jdt.internal.compiler.ast.MessageSend;
import org.eclipse.jdt.internal.compiler.ast.MethodDeclaration;
import org.eclipse.jdt.internal.compiler.ast.NameReference;
import org.eclipse.jdt.internal.compiler.ast.OperatorIds;
import org.eclipse.jdt.internal.compiler.ast.QualifiedNameReference;
import org.eclipse.jdt.internal.compiler.ast.QualifiedTypeReference;
import org.eclipse.jdt.internal.compiler.ast.ReturnStatement;
import org.eclipse.jdt.internal.compiler.ast.SingleNameReference;
import org.eclipse.jdt.internal.compiler.ast.Statement;
import org.eclipse.jdt.internal.compiler.ast.StringLiteral;
import org.eclipse.jdt.internal.compiler.ast.SuperReference;
import org.eclipse.jdt.internal.compiler.ast.TypeDeclaration;
import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;
import org.eclipse.jdt.internal.compiler.lookup.TypeConstants;
import org.mangosdk.spi.ProviderFor;
/**
* Handles the <code>ToString</code> annotation for eclipse.
*/
@ProviderFor(EclipseAnnotationHandler.class)
public class HandleToString implements EclipseAnnotationHandler<ToString> {
private void checkForBogusExcludes(Node type, AnnotationValues<ToString> annotation) {
List<String> list = Arrays.asList(annotation.getInstance().exclude());
boolean[] matched = new boolean[list.size()];
for ( Node child : type.down() ) {
if ( list.isEmpty() ) break;
if ( child.getKind() != Kind.FIELD ) continue;
if ( (((FieldDeclaration)child.get()).modifiers & ClassFileConstants.AccStatic) != 0 ) continue;
int idx = list.indexOf(child.getName());
if ( idx > -1 ) matched[idx] = true;
}
for ( int i = 0 ; i < list.size() ; i++ ) {
if ( !matched[i] ) {
annotation.setWarning("exclude", "This field does not exist, or would have been excluded anyway.", i);
}
}
}
public void generateToStringForType(Node typeNode, Node errorNode) {
for ( Node child : typeNode.down() ) {
if ( child.getKind() == Kind.ANNOTATION ) {
if ( Eclipse.annotationTypeMatches(ToString.class, child) ) {
//The annotation will make it happen, so we can skip it.
return;
}
}
}
boolean includeFieldNames = false;
boolean callSuper = false;
try {
includeFieldNames = ((Boolean)ToString.class.getMethod("includeFieldNames").getDefaultValue()).booleanValue();
} catch ( Exception ignore ) {}
try {
callSuper = ((Boolean)ToString.class.getMethod("callSuper").getDefaultValue()).booleanValue();
} catch ( Exception ignore ) {}
generateToString(typeNode, errorNode, Collections.<String>emptyList(),includeFieldNames, callSuper, false);
}
public boolean handle(AnnotationValues<ToString> annotation, Annotation ast, Node annotationNode) {
ToString ann = annotation.getInstance();
List<String> excludes = Arrays.asList(ann.exclude());
Node typeNode = annotationNode.up();
checkForBogusExcludes(typeNode, annotation);
return generateToString(typeNode, annotationNode, excludes, ann.includeFieldNames(), ann.callSuper(), true);
}
public boolean generateToString(Node typeNode, Node errorNode, List<String> excludes,
boolean includeFieldNames, boolean callSuper, boolean whineIfExists) {
TypeDeclaration typeDecl = null;
if ( typeNode.get() instanceof TypeDeclaration ) typeDecl = (TypeDeclaration) typeNode.get();
int modifiers = typeDecl == null ? 0 : typeDecl.modifiers;
boolean notAClass = (modifiers &
(ClassFileConstants.AccInterface | ClassFileConstants.AccAnnotation | ClassFileConstants.AccEnum)) != 0;
if ( typeDecl == null || notAClass ) {
errorNode.addError("@ToString is only supported on a class.");
return false;
}
List<Node> nodesForToString = new ArrayList<Node>();
for ( Node child : typeNode.down() ) {
if ( child.getKind() != Kind.FIELD ) continue;
FieldDeclaration fieldDecl = (FieldDeclaration) child.get();
//Skip static fields.
if ( (fieldDecl.modifiers & ClassFileConstants.AccStatic) != 0 ) continue;
//Skip excluded fields
if ( excludes.contains(new String(fieldDecl.name)) ) continue;
nodesForToString.add(child);
}
switch ( methodExists("toString", typeNode) ) {
case NOT_EXISTS:
MethodDeclaration toString = createToString(typeNode, nodesForToString, includeFieldNames, callSuper, errorNode.get());
injectMethod(typeNode, toString);
return true;
case EXISTS_BY_LOMBOK:
return true;
default:
case EXISTS_BY_USER:
if ( whineIfExists ) {
errorNode.addWarning("Not generating toString(): A method with that name already exists");
}
return true;
}
}
private MethodDeclaration createToString(Node type, Collection<Node> fields, boolean includeFieldNames, boolean callSuper, ASTNode pos) {
char[] rawTypeName = ((TypeDeclaration)type.get()).name;
String typeName = rawTypeName == null ? "" : new String(rawTypeName);
char[] prefix = (typeName + "(").toCharArray();
char[] suffix = ")".toCharArray();
char[] infix = ", ".toCharArray();
long p = (long)pos.sourceStart << 32 | pos.sourceEnd;
final int PLUS = OperatorIds.PLUS;
boolean first = true;
Expression current = new StringLiteral(prefix, 0, 0, 0);
if ( callSuper ) {
MessageSend callToSuper = new MessageSend();
callToSuper.receiver = new SuperReference(0, 0);
callToSuper.selector = "toString".toCharArray();
current = new BinaryExpression(current, new StringLiteral("super=[".toCharArray(), 0, 0, 0), PLUS);
current = new BinaryExpression(current, callToSuper, PLUS);
current = new BinaryExpression(current, new StringLiteral(new char[] { ']' }, 0, 0, 0), PLUS);
first = false;
}
for ( Node field : fields ) {
FieldDeclaration f = (FieldDeclaration)field.get();
if ( f.name == null || f.type == null ) continue;
if ( !first ) {
current = new BinaryExpression(current, new StringLiteral(infix, 0, 0, 0), PLUS);
}
else first = false;
Expression ex;
if ( f.type.dimensions() > 0 ) {
MessageSend arrayToString = new MessageSend();
arrayToString.receiver = generateQualifiedNameRef(TypeConstants.JAVA, TypeConstants.UTIL, "Arrays".toCharArray());
arrayToString.arguments = new Expression[] { new SingleNameReference(f.name, p) };
if ( f.type.dimensions() > 1 || !BUILT_IN_TYPES.contains(new String(f.type.getLastToken())) ) {
arrayToString.selector = "deepToString".toCharArray();
} else {
arrayToString.selector = "toString".toCharArray();
}
ex = arrayToString;
} else ex = new SingleNameReference(f.name, p);
if ( includeFieldNames ) {
char[] namePlusEqualsSign = (new String(f.name) + "=").toCharArray();
current = new BinaryExpression(current, new StringLiteral(namePlusEqualsSign, 0, 0, 0), PLUS);
}
current = new BinaryExpression(current, ex, PLUS);
}
current = new BinaryExpression(current, new StringLiteral(suffix, 0, 0, 0), PLUS);
ReturnStatement returnStatement = new ReturnStatement(current, (int)(p >> 32), (int)p);
MethodDeclaration method = new MethodDeclaration(((CompilationUnitDeclaration) type.top().get()).compilationResult);
method.modifiers = PKG.toModifier(AccessLevel.PUBLIC);
method.returnType = new QualifiedTypeReference(TypeConstants.JAVA_LANG_STRING, new long[] {0, 0, 0});
method.annotations = new Annotation[] {
new MarkerAnnotation(new QualifiedTypeReference(TypeConstants.JAVA_LANG_OVERRIDE, new long[] { 0, 0, 0}), 0)
};
method.arguments = null;
method.selector = "toString".toCharArray();
method.thrownExceptions = null;
method.typeParameters = null;
method.bits |= Eclipse.ECLIPSE_DO_NOT_TOUCH_FLAG;
method.bodyStart = method.declarationSourceStart = method.sourceStart = pos.sourceStart;
method.bodyEnd = method.declarationSourceEnd = method.sourceEnd = pos.sourceEnd;
method.statements = new Statement[] { returnStatement };
return method;
}
private static final Set<String> BUILT_IN_TYPES = Collections.unmodifiableSet(new HashSet<String>(Arrays.asList(
"byte", "short", "int", "long", "char", "boolean", "double", "float")));
private NameReference generateQualifiedNameRef(char[]... varNames) {
if ( varNames.length > 1 )
return new QualifiedNameReference(varNames, new long[varNames.length], 0, 0);
else return new SingleNameReference(varNames[0], 0);
}
}
src/lombok/javac/handlers/HandleData.java
+2 -40
View File
@@ -92,6 +92,8 @@ public class HandleData implements JavacAnnotationHandler<Data> {
if ( !isFinal ) new HandleSetter().generateSetterForField(child, annotationNode.get());
}
new HandleToString().generateToStringForType(typeNode, annotationNode);
if ( methodExists("equals", typeNode) == MemberExistsResult.NOT_EXISTS ) {
JCMethodDecl method = createEquals(typeNode, nodesForEquality);
injectMethod(typeNode, method);
@@ -102,11 +104,6 @@ public class HandleData implements JavacAnnotationHandler<Data> {
injectMethod(typeNode, method);
}
if ( methodExists("toString", typeNode) == MemberExistsResult.NOT_EXISTS ) {
JCMethodDecl method = createToString(typeNode, nodesForToString);
injectMethod(typeNode, method);
}
String staticConstructorName = annotation.getInstance().staticConstructor();
if ( constructorExists(typeNode) == MemberExistsResult.NOT_EXISTS ) {
@@ -122,41 +119,6 @@ public class HandleData implements JavacAnnotationHandler<Data> {
return true;
}
private JCMethodDecl createToString(Node typeNode, List<Node> fields) {
TreeMaker maker = typeNode.getTreeMaker();
JCAnnotation overrideAnnotation = maker.Annotation(chainDots(maker, typeNode, "java", "lang", "Override"), List.<JCExpression>nil());
JCModifiers mods = maker.Modifiers(Flags.PUBLIC, List.of(overrideAnnotation));
JCExpression returnType = chainDots(maker, typeNode, "java", "lang", "String");
JCExpression current = maker.Literal(((JCClassDecl) typeNode.get()).name.toString() + "(");
boolean first = true;
for ( Node fieldNode : fields ) {
JCVariableDecl field = (JCVariableDecl) fieldNode.get();
if ( !first ) current = maker.Binary(JCTree.PLUS, current, maker.Literal(", "));
first = false;
if ( field.vartype instanceof JCArrayTypeTree ) {
boolean multiDim = ((JCArrayTypeTree)field.vartype).elemtype instanceof JCArrayTypeTree;
boolean primitiveArray = ((JCArrayTypeTree)field.vartype).elemtype instanceof JCPrimitiveTypeTree;
boolean useDeepTS = multiDim || !primitiveArray;
JCExpression hcMethod = chainDots(maker, typeNode, "java", "util", "Arrays", useDeepTS ? "deepToString" : "toString");
current = maker.Binary(JCTree.PLUS, current, maker.Apply(
List.<JCExpression>nil(), hcMethod, List.<JCExpression>of(maker.Ident(field.name))));
} else current = maker.Binary(JCTree.PLUS, current, maker.Ident(field.name));
}
current = maker.Binary(JCTree.PLUS, current, maker.Literal(")"));
JCStatement returnStatement = maker.Return(current);
JCBlock body = maker.Block(0, List.of(returnStatement));
return maker.MethodDef(mods, typeNode.toName("toString"), returnType,
List.<JCTypeParameter>nil(), List.<JCVariableDecl>nil(), List.<JCExpression>nil(), body, null);
}
private JCMethodDecl createHashCode(Node typeNode, List<Node> fields) {
TreeMaker maker = typeNode.getTreeMaker();
src/lombok/javac/handlers/HandleToString.java
+196
View File
@@ -0,0 +1,196 @@
/*
* Copyright © 2009 Reinier Zwitserloot and Roel Spilker.
*
* 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.PKG.*;
import lombok.ToString;
import lombok.core.AnnotationValues;
import lombok.core.AST.Kind;
import lombok.javac.Javac;
import lombok.javac.JavacAnnotationHandler;
import lombok.javac.JavacAST.Node;
import org.mangosdk.spi.ProviderFor;
import com.sun.tools.javac.code.Flags;
import com.sun.tools.javac.tree.JCTree;
import com.sun.tools.javac.tree.TreeMaker;
import com.sun.tools.javac.tree.JCTree.JCAnnotation;
import com.sun.tools.javac.tree.JCTree.JCArrayTypeTree;
import com.sun.tools.javac.tree.JCTree.JCBlock;
import com.sun.tools.javac.tree.JCTree.JCClassDecl;
import com.sun.tools.javac.tree.JCTree.JCExpression;
import com.sun.tools.javac.tree.JCTree.JCMethodDecl;
import com.sun.tools.javac.tree.JCTree.JCMethodInvocation;
import com.sun.tools.javac.tree.JCTree.JCModifiers;
import com.sun.tools.javac.tree.JCTree.JCPrimitiveTypeTree;
import com.sun.tools.javac.tree.JCTree.JCStatement;
import com.sun.tools.javac.tree.JCTree.JCTypeParameter;
import com.sun.tools.javac.tree.JCTree.JCVariableDecl;
import com.sun.tools.javac.util.List;
/**
* Handles the <code>ToString</code> annotation for javac.
*/
@ProviderFor(JavacAnnotationHandler.class)
public class HandleToString implements JavacAnnotationHandler<ToString> {
private void checkForBogusExcludes(Node type, AnnotationValues<ToString> annotation) {
List<String> list = List.from(annotation.getInstance().exclude());
boolean[] matched = new boolean[list.size()];
for ( Node child : type.down() ) {
if ( list.isEmpty() ) break;
if ( child.getKind() != Kind.FIELD ) continue;
if ( (((JCVariableDecl)child.get()).mods.flags & Flags.STATIC) != 0 ) continue;
int idx = list.indexOf(child.getName());
if ( idx > -1 ) matched[idx] = true;
}
for ( int i = 0 ; i < list.size() ; i++ ) {
if ( !matched[i] ) {
annotation.setWarning("exclude", "This field does not exist, or would have been excluded anyway.", i);
}
}
}
@Override public boolean handle(AnnotationValues<ToString> annotation, JCAnnotation ast, Node annotationNode) {
ToString ann = annotation.getInstance();
List<String> excludes = List.from(ann.exclude());
Node typeNode = annotationNode.up();
checkForBogusExcludes(typeNode, annotation);
return generateToString(typeNode, annotationNode, excludes, ann.includeFieldNames(), ann.callSuper(), true);
}
public void generateToStringForType(Node typeNode, Node errorNode) {
for ( Node child : typeNode.down() ) {
if ( child.getKind() == Kind.ANNOTATION ) {
if ( Javac.annotationTypeMatches(ToString.class, child) ) {
//The annotation will make it happen, so we can skip it.
return;
}
}
}
boolean includeFieldNames = false;
boolean callSuper = false;
try {
includeFieldNames = ((Boolean)ToString.class.getMethod("includeFieldNames").getDefaultValue()).booleanValue();
} catch ( Exception ignore ) {}
try {
callSuper = ((Boolean)ToString.class.getMethod("callSuper").getDefaultValue()).booleanValue();
} catch ( Exception ignore ) {}
generateToString(typeNode, errorNode, List.<String>nil(),includeFieldNames, callSuper, false);
}
private boolean generateToString(Node typeNode, Node errorNode, List<String> excludes,
boolean includeFieldNames, boolean callSuper, boolean whineIfExists) {
boolean notAClass = true;
if ( typeNode.get() instanceof JCClassDecl ) {
long flags = ((JCClassDecl)typeNode.get()).mods.flags;
notAClass = (flags & (Flags.INTERFACE | Flags.ANNOTATION | Flags.ENUM)) != 0;
}
if ( notAClass ) {
errorNode.addError("@ToString is only supported on a class.");
return false;
}
List<Node> nodesForToString = List.nil();
for ( Node child : typeNode.down() ) {
if ( child.getKind() != Kind.FIELD ) continue;
JCVariableDecl fieldDecl = (JCVariableDecl) child.get();
//Skip static fields.
if ( (fieldDecl.mods.flags & Flags.STATIC) != 0 ) continue;
//Skip excluded fields
if ( excludes.contains(fieldDecl.name.toString()) ) continue;
nodesForToString = nodesForToString.append(child);
}
switch ( methodExists("toString", typeNode) ) {
case NOT_EXISTS:
JCMethodDecl method = createToString(typeNode, nodesForToString, includeFieldNames, callSuper);
injectMethod(typeNode, method);
return true;
case EXISTS_BY_LOMBOK:
return true;
default:
case EXISTS_BY_USER:
if ( whineIfExists ) {
errorNode.addWarning("Not generating toString(): A method with that name already exists");
}
return true;
}
}
private JCMethodDecl createToString(Node typeNode, List<Node> fields, boolean includeFieldNames, boolean callSuper) {
TreeMaker maker = typeNode.getTreeMaker();
JCAnnotation overrideAnnotation = maker.Annotation(chainDots(maker, typeNode, "java", "lang", "Override"), List.<JCExpression>nil());
JCModifiers mods = maker.Modifiers(Flags.PUBLIC, List.of(overrideAnnotation));
JCExpression returnType = chainDots(maker, typeNode, "java", "lang", "String");
JCExpression current = maker.Literal(((JCClassDecl) typeNode.get()).name.toString() + "(");
boolean first = true;
if ( callSuper ) {
current = maker.Binary(JCTree.PLUS, current, maker.Literal("super=["));
JCMethodInvocation callToSuper = maker.Apply(List.<JCExpression>nil(),
maker.Select(maker.Ident(typeNode.toName("super")), typeNode.toName("toString")),
List.<JCExpression>nil());
current = maker.Binary(JCTree.PLUS, current, callToSuper);
current = maker.Binary(JCTree.PLUS, current, maker.Literal("]"));
first = false;
}
for ( Node fieldNode : fields ) {
JCVariableDecl field = (JCVariableDecl) fieldNode.get();
if ( !first ) current = maker.Binary(JCTree.PLUS, current, maker.Literal(", "));
first = false;
if ( includeFieldNames ) {
current = maker.Binary(JCTree.PLUS, current, maker.Literal(fieldNode.getName() + "="));
}
if ( field.vartype instanceof JCArrayTypeTree ) {
boolean multiDim = ((JCArrayTypeTree)field.vartype).elemtype instanceof JCArrayTypeTree;
boolean primitiveArray = ((JCArrayTypeTree)field.vartype).elemtype instanceof JCPrimitiveTypeTree;
boolean useDeepTS = multiDim || !primitiveArray;
JCExpression hcMethod = chainDots(maker, typeNode, "java", "util", "Arrays", useDeepTS ? "deepToString" : "toString");
current = maker.Binary(JCTree.PLUS, current, maker.Apply(
List.<JCExpression>nil(), hcMethod, List.<JCExpression>of(maker.Ident(field.name))));
} else current = maker.Binary(JCTree.PLUS, current, maker.Ident(field.name));
}
current = maker.Binary(JCTree.PLUS, current, maker.Literal(")"));
JCStatement returnStatement = maker.Return(current);
JCBlock body = maker.Block(0, List.of(returnStatement));
return maker.MethodDef(mods, typeNode.toName("toString"), returnType,
List.<JCTypeParameter>nil(), List.<JCVariableDecl>nil(), List.<JCExpression>nil(), body, null);
}
}