aboutsummaryrefslogtreecommitdiff
path: root/src/lombok/eclipse/handlers/HandleData.java
diff options
context:
space:
mode:
Diffstat (limited to 'src/lombok/eclipse/handlers/HandleData.java')
-rw-r--r--src/lombok/eclipse/handlers/HandleData.java139
1 files changed, 97 insertions, 42 deletions
diff --git a/src/lombok/eclipse/handlers/HandleData.java b/src/lombok/eclipse/handlers/HandleData.java
index dd398d74..27757e7d 100644
--- a/src/lombok/eclipse/handlers/HandleData.java
+++ b/src/lombok/eclipse/handlers/HandleData.java
@@ -1,11 +1,11 @@
package lombok.eclipse.handlers;
+import static lombok.eclipse.Eclipse.*;
import static lombok.eclipse.handlers.PKG.*;
import java.lang.reflect.Modifier;
import java.util.ArrayList;
import java.util.Collection;
-import java.util.Collections;
import java.util.List;
import lombok.AccessLevel;
@@ -15,22 +15,28 @@ import lombok.core.AST.Kind;
import lombok.eclipse.Eclipse;
import lombok.eclipse.EclipseAnnotationHandler;
import lombok.eclipse.EclipseAST.Node;
+import lombok.eclipse.handlers.PKG.MethodExistsResult;
import org.eclipse.jdt.internal.compiler.ast.ASTNode;
-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.Argument;
import org.eclipse.jdt.internal.compiler.ast.Assignment;
import org.eclipse.jdt.internal.compiler.ast.BinaryExpression;
+import org.eclipse.jdt.internal.compiler.ast.CastExpression;
import org.eclipse.jdt.internal.compiler.ast.CompilationUnitDeclaration;
import org.eclipse.jdt.internal.compiler.ast.ConstructorDeclaration;
+import org.eclipse.jdt.internal.compiler.ast.EqualExpression;
import org.eclipse.jdt.internal.compiler.ast.ExplicitConstructorCall;
import org.eclipse.jdt.internal.compiler.ast.Expression;
+import org.eclipse.jdt.internal.compiler.ast.FalseLiteral;
import org.eclipse.jdt.internal.compiler.ast.FieldDeclaration;
import org.eclipse.jdt.internal.compiler.ast.FieldReference;
+import org.eclipse.jdt.internal.compiler.ast.IfStatement;
+import org.eclipse.jdt.internal.compiler.ast.LocalDeclaration;
+import org.eclipse.jdt.internal.compiler.ast.MessageSend;
import org.eclipse.jdt.internal.compiler.ast.MethodDeclaration;
+import org.eclipse.jdt.internal.compiler.ast.NullLiteral;
import org.eclipse.jdt.internal.compiler.ast.OperatorIds;
import org.eclipse.jdt.internal.compiler.ast.QualifiedTypeReference;
import org.eclipse.jdt.internal.compiler.ast.ReturnStatement;
@@ -39,15 +45,12 @@ 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;
-import org.eclipse.jdt.internal.compiler.ast.TypeParameter;
+import org.eclipse.jdt.internal.compiler.ast.TypeReference;
import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;
-import org.eclipse.jdt.internal.compiler.lookup.BaseTypeBinding;
-import org.eclipse.jdt.internal.compiler.lookup.MethodBinding;
-import org.eclipse.jdt.internal.compiler.lookup.MethodScope;
-import org.eclipse.jdt.internal.compiler.lookup.TypeBinding;
import org.eclipse.jdt.internal.compiler.lookup.TypeConstants;
-import org.eclipse.jdt.internal.compiler.lookup.TypeVariableBinding;
+import org.eclipse.jdt.internal.compiler.lookup.TypeIds;
import org.mangosdk.spi.ProviderFor;
@ProviderFor(EclipseAnnotationHandler.class)
@@ -81,42 +84,22 @@ public class HandleData implements EclipseAnnotationHandler<Data> {
new HandleSetter().generateSetterForField(child, annotationNode.get());
}
- switch ( methodExists("toString", typeNode) ) {
- case NOT_EXISTS:
+ if ( methodExists("toString", typeNode) == MethodExistsResult.NOT_EXISTS ) {
MethodDeclaration toString = createToString(typeNode, nodesForConstructorAndToString, ast);
injectMethod(typeNode, toString);
- //fallthrough
- case EXISTS_BY_LOMBOK:
-// TypeBinding javaLangString = null;
-// if ( typeDecl.scope != null ) javaLangString = typeDecl.scope.getJavaLangString();
-// fixMethodBinding(getExistingLombokMethod("toString", typeNode), javaLangString, Collections.<Node>emptyList());
}
- switch ( constructorExists(typeNode) ) {
- case NOT_EXISTS:
+ if ( constructorExists(typeNode) == MethodExistsResult.NOT_EXISTS ) {
ConstructorDeclaration constructor = createConstructor(
ann.staticConstructor().isEmpty(), typeNode, nodesForConstructorAndToString, ast);
injectMethod(typeNode, constructor);
- //fallthrough
- case EXISTS_BY_LOMBOK:
-// constructor = createConstructor(
-// ann.staticConstructor().isEmpty(), typeNode, nodesForConstructorAndToString, ast);
-// injectScopeIntoConstructor(constructor, nodesForConstructorAndToString, typeDecl);
-// fixMethodBinding(getExistingLombokConstructor(typeNode), typeDecl.binding, nodesForConstructorAndToString);
}
if ( !ann.staticConstructor().isEmpty() ) {
- switch ( methodExists("of", typeNode) ) {
- case NOT_EXISTS:
+ if ( methodExists("of", typeNode) == MethodExistsResult.NOT_EXISTS ) {
MethodDeclaration staticConstructor = createStaticConstructor(
ann.staticConstructor(), typeNode, nodesForConstructorAndToString, ast);
injectMethod(typeNode, staticConstructor);
- //fallthrough
- case EXISTS_BY_LOMBOK:
-// fixMethodBinding(getExistingLombokMethod(ann.staticConstructor(), typeNode), typeDecl.binding, nodesForConstructorAndToString);
-// injectScopeIntoStaticConstructor((MethodDeclaration) getExistingLombokMethod(
-// ann.staticConstructor(), typeNode).get(),
-// nodesForConstructorAndToString, typeDecl);
}
}
@@ -190,7 +173,7 @@ public class HandleData implements EclipseAnnotationHandler<Data> {
thisX.token = field.name;
assigns.add(new Assignment(thisX, new SingleNameReference(field.name, p), (int)p));
long fieldPos = (((long)field.sourceStart) << 32) | field.sourceEnd;
- args.add(new Argument(field.name, fieldPos, field.type, 0));
+ args.add(new Argument(field.name, fieldPos, copyType(field.type), 0));
}
constructor.statements = assigns.toArray(new Statement[assigns.size()]);
@@ -209,7 +192,7 @@ public class HandleData implements EclipseAnnotationHandler<Data> {
constructor.annotations = null;
constructor.selector = name.toCharArray();
constructor.thrownExceptions = null;
- constructor.typeParameters = null;
+ constructor.typeParameters = copyTypeParams(((TypeDeclaration)type.get()).typeParameters);
constructor.bits |= Eclipse.ECLIPSE_DO_NOT_TOUCH_FLAG;
constructor.bodyStart = constructor.declarationSourceStart = constructor.sourceStart = pos.sourceStart;
constructor.bodyEnd = constructor.declarationSourceEnd = constructor.sourceEnd = pos.sourceEnd;
@@ -217,13 +200,13 @@ public class HandleData implements EclipseAnnotationHandler<Data> {
List<Argument> args = new ArrayList<Argument>();
List<Expression> assigns = new ArrayList<Expression>();
AllocationExpression statement = new AllocationExpression();
- statement.type = constructor.returnType;
+ statement.type = copyType(constructor.returnType);
for ( Node fieldNode : fields ) {
FieldDeclaration field = (FieldDeclaration) fieldNode.get();
long fieldPos = (((long)field.sourceStart) << 32) | field.sourceEnd;
assigns.add(new SingleNameReference(field.name, fieldPos));
- args.add(new Argument(field.name, fieldPos, field.type, 0));
+ args.add(new Argument(field.name, fieldPos, copyType(field.type), 0));
}
statement.arguments = assigns.toArray(new Expression[assigns.size()]);
@@ -232,14 +215,86 @@ public class HandleData implements EclipseAnnotationHandler<Data> {
return constructor;
}
- private MethodDeclaration createEquals(Collection<Node> fields) {
- //If using an of() constructor, make private.
- //method params
- //on loop: Assignment(FieldReference(ThisReference, "x"), SingleNameReference("x"))
- return null;
+ private MethodDeclaration createEquals(Node type, Collection<Node> fields, ASTNode pos) {
+ long p = (long)pos.sourceStart << 32 | pos.sourceEnd;
+ MethodDeclaration method = new MethodDeclaration(
+ ((CompilationUnitDeclaration) type.top().get()).compilationResult);
+
+ method.modifiers = PKG.toModifier(AccessLevel.PUBLIC);
+ method.returnType = TypeReference.baseTypeReference(TypeIds.T_boolean, 0);
+ method.annotations = null;
+ method.selector = "equals".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.arguments = new Argument[] {
+ new Argument(new char[] { 'o' }, 0,
+ new QualifiedTypeReference(TypeConstants.JAVA_LANG_OBJECT, new long[] { 0, 0, 0 }), 0)
+ };
+
+ List<Statement> statements = new ArrayList<Statement>();
+
+ /* if ( o == this ) return true; */ {
+ EqualExpression otherEqualsThis = new EqualExpression(
+ new SingleNameReference(new char[] { 'o' }, 0),
+ new ThisReference(0, 0), OperatorIds.EQUAL_EQUAL);
+
+ ReturnStatement returnTrue = new ReturnStatement(new TrueLiteral(0, 0), 0, 0);
+ IfStatement ifOtherEqualsThis = new IfStatement(otherEqualsThis, returnTrue, 0, 0);
+ statements.add(ifOtherEqualsThis);
+ }
+
+ /* if ( o == null ) return false; */ {
+ EqualExpression otherEqualsNull = new EqualExpression(
+ new SingleNameReference(new char[] { 'o' }, 0),
+ new NullLiteral(0, 0), OperatorIds.EQUAL_EQUAL);
+
+ ReturnStatement returnFalse = new ReturnStatement(new FalseLiteral(0, 0), 0, 0);
+ IfStatement ifOtherEqualsNull = new IfStatement(otherEqualsNull, returnFalse, 0, 0);
+ statements.add(ifOtherEqualsNull);
+ }
+
+ /* if ( o.getClass() != getClass() ) return false; */ {
+ MessageSend otherGetClass = new MessageSend();
+ otherGetClass.receiver = new SingleNameReference(new char[] { 'o' }, 0);
+ otherGetClass.selector = "getClass".toCharArray();
+ MessageSend thisGetClass = new MessageSend();
+ thisGetClass.receiver = new ThisReference(0, 0);
+ thisGetClass.selector = "getClass".toCharArray();
+ EqualExpression classesNotEqual = new EqualExpression(otherGetClass, thisGetClass, OperatorIds.NOT_EQUAL);
+ ReturnStatement returnFalse = new ReturnStatement(new FalseLiteral(0, 0), 0, 0);
+ IfStatement ifClassesNotEqual = new IfStatement(classesNotEqual, returnFalse, 0, 0);
+ statements.add(ifClassesNotEqual);
+ }
+
+ char[] otherN = "other".toCharArray();
+
+ //TODO fix generics raw type warnings by inserting Wildcards.
+ /* MyType other = (MyType) o; */ {
+ if ( !fields.isEmpty() ) {
+ LocalDeclaration other = new LocalDeclaration(otherN, 0, 0);
+ other.initialization = new CastExpression(
+ new SingleNameReference(new char[] { 'o' }, 0),
+ new SingleNameReference(((TypeDeclaration)type.get()).name, 0));
+ }
+ }
+
+ for ( Node field : fields ) {
+ FieldDeclaration f = (FieldDeclaration) field.get();
+ //compare if primitive, write per-primitive special code, otherwise use == null ? other == null ? .equals(other).
+ //TODO I LEFT IT HERE
+ }
+
+ /* return true; */ {
+ statements.add(new ReturnStatement(new TrueLiteral(0, 0), 0, 0));
+ }
+ method.statements = statements.toArray(new Statement[statements.size()]);
+ return method;
}
- private MethodDeclaration createHashCode(Collection<Node> fields) {
+ private MethodDeclaration createHashCode(Node type, Collection<Node> fields, ASTNode pos) {
//booleans: conditionalexpression that bounces between 1231 and 1237.
//longs: (int) (lng ^ (lng >>> 32));
//doubles and floats: Double.doubleToLongBits, then as long.
generated by cgit (git 2.46.0) at 2024-11-24 13:53:45 +0000