aboutsummaryrefslogtreecommitdiff
path: root/src/core/lombok
diff options
context:
space:
mode:
Diffstat (limited to 'src/core/lombok')
-rw-r--r--src/core/lombok/eclipse/handlers/HandleGetter.java246
1 files changed, 236 insertions, 10 deletions
diff --git a/src/core/lombok/eclipse/handlers/HandleGetter.java b/src/core/lombok/eclipse/handlers/HandleGetter.java
index e5ddbc3f..56d0ba6c 100644
--- a/src/core/lombok/eclipse/handlers/HandleGetter.java
+++ b/src/core/lombok/eclipse/handlers/HandleGetter.java
@@ -25,6 +25,9 @@ import static lombok.eclipse.Eclipse.*;
import static lombok.eclipse.handlers.EclipseHandlerUtil.*;
import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
import lombok.AccessLevel;
import lombok.Getter;
@@ -34,14 +37,30 @@ import lombok.core.handlers.TransformationsUtil;
import lombok.eclipse.Eclipse;
import lombok.eclipse.EclipseAnnotationHandler;
import lombok.eclipse.EclipseNode;
+import lombok.eclipse.handlers.EclipseHandlerUtil.FieldAccess;
import org.eclipse.jdt.internal.compiler.ast.ASTNode;
+import org.eclipse.jdt.internal.compiler.ast.AllocationExpression;
import org.eclipse.jdt.internal.compiler.ast.Annotation;
+import org.eclipse.jdt.internal.compiler.ast.ArrayTypeReference;
+import org.eclipse.jdt.internal.compiler.ast.Assignment;
+import org.eclipse.jdt.internal.compiler.ast.BinaryExpression;
+import org.eclipse.jdt.internal.compiler.ast.Block;
+import org.eclipse.jdt.internal.compiler.ast.EqualExpression;
import org.eclipse.jdt.internal.compiler.ast.Expression;
import org.eclipse.jdt.internal.compiler.ast.FieldDeclaration;
+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.ParameterizedQualifiedTypeReference;
+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.SingleTypeReference;
import org.eclipse.jdt.internal.compiler.ast.Statement;
+import org.eclipse.jdt.internal.compiler.ast.SynchronizedStatement;
import org.eclipse.jdt.internal.compiler.ast.TypeDeclaration;
import org.eclipse.jdt.internal.compiler.ast.TypeReference;
import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;
@@ -123,7 +142,7 @@ public class HandleGetter implements EclipseAnnotationHandler<Getter> {
boolean lazy = annotationInstance.lazy();
if (level == AccessLevel.NONE) {
if (lazy) {
- annotationNode.addWarning("'lazy' requires AccessLevel.PRIVATE or higher.");
+ annotationNode.addWarning("'lazy' does not work with AccessLevel.NONE.");
}
return true;
}
@@ -158,7 +177,7 @@ public class HandleGetter implements EclipseAnnotationHandler<Getter> {
FieldDeclaration field = (FieldDeclaration) fieldNode.get();
if (lazy) {
- if ((field.modifiers & (ClassFileConstants.AccPrivate | ClassFileConstants.AccFinal)) != 0) {
+ if ((field.modifiers & ClassFileConstants.AccPrivate) == 0 || (field.modifiers & ClassFileConstants.AccFinal) == 0) {
errorNode.addError("'lazy' requires the field to be private and final.");
return true;
}
@@ -193,7 +212,7 @@ public class HandleGetter implements EclipseAnnotationHandler<Getter> {
}
}
- MethodDeclaration method = generateGetter((TypeDeclaration) fieldNode.up().get(), fieldNode, getterName, modifier, source);
+ MethodDeclaration method = generateGetter((TypeDeclaration) fieldNode.up().get(), fieldNode, getterName, modifier, source, lazy);
Annotation[] copiedAnnotations = copyAnnotations(source, findAnnotations(field, TransformationsUtil.NON_NULL_PATTERN), findAnnotations(field, TransformationsUtil.NULLABLE_PATTERN), onMethod);
if (copiedAnnotations.length != 0) {
method.annotations = copiedAnnotations;
@@ -204,12 +223,22 @@ public class HandleGetter implements EclipseAnnotationHandler<Getter> {
return true;
}
- private MethodDeclaration generateGetter(TypeDeclaration parent, EclipseNode fieldNode, String name, int modifier, ASTNode source) {
- FieldDeclaration field = (FieldDeclaration) fieldNode.get();
+ private MethodDeclaration generateGetter(TypeDeclaration parent, EclipseNode fieldNode, String name, int modifier, ASTNode source, boolean lazy) {
+
+ // Remember the type; lazy will change it;
+ TypeReference returnType = copyType(((FieldDeclaration) fieldNode.get()).type, source);
+
+ Statement[] statements;
+ if (lazy) {
+ statements = createLazyGetterBody(source, fieldNode);
+ } else {
+ statements = createSimpleGetterBody(source, fieldNode);
+ }
+
MethodDeclaration method = new MethodDeclaration(parent.compilationResult);
Eclipse.setGeneratedBy(method, source);
method.modifiers = modifier;
- method.returnType = copyType(field.type, source);
+ method.returnType = returnType;
method.annotations = null;
method.arguments = null;
method.selector = name.toCharArray();
@@ -217,12 +246,209 @@ public class HandleGetter implements EclipseAnnotationHandler<Getter> {
method.thrownExceptions = null;
method.typeParameters = null;
method.bits |= ECLIPSE_DO_NOT_TOUCH_FLAG;
- Expression fieldRef = createFieldAccessor(fieldNode, FieldAccess.ALWAYS_FIELD, source);
- Statement returnStatement = new ReturnStatement(fieldRef, field.sourceStart, field.sourceEnd);
- Eclipse.setGeneratedBy(returnStatement, source);
method.bodyStart = method.declarationSourceStart = method.sourceStart = source.sourceStart;
method.bodyEnd = method.declarationSourceEnd = method.sourceEnd = source.sourceEnd;
- method.statements = new Statement[] { returnStatement };
+ method.statements = statements;
return method;
}
+
+ private Statement[] createSimpleGetterBody(ASTNode source, EclipseNode fieldNode) {
+ FieldDeclaration field = (FieldDeclaration) fieldNode.get();
+ Expression fieldRef = createFieldAccessor(fieldNode, FieldAccess.ALWAYS_FIELD, source);
+ Statement returnStatement = new ReturnStatement(fieldRef, field.sourceStart, field.sourceEnd);
+ Eclipse.setGeneratedBy(returnStatement, source);
+ return new Statement[] {returnStatement};
+ }
+
+ private static final char[][] AR = fromQualifiedName("java.util.concurrent.atomic.AtomicReference");
+ private static final TypeReference[][] AR_PARAMS = new TypeReference[5][];
+
+ private static final java.util.Map<String, char[][]> TYPE_MAP;
+ static {
+ Map<String, char[][]> m = new HashMap<String, char[][]>();
+ m.put("int", fromQualifiedName("java.lang.Integer"));
+ m.put("double", fromQualifiedName("java.lang.Double"));
+ m.put("float", fromQualifiedName("java.lang.Float"));
+ m.put("short", fromQualifiedName("java.lang.Short"));
+ m.put("byte", fromQualifiedName("java.lang.Byte"));
+ m.put("long", fromQualifiedName("java.lang.Long"));
+ m.put("boolean", fromQualifiedName("java.lang.Boolean"));
+ m.put("char", fromQualifiedName("java.lang.Character"));
+ TYPE_MAP = Collections.unmodifiableMap(m);
+ }
+
+ private static char[] valueName = "value".toCharArray();
+
+ private Statement[] createLazyGetterBody(ASTNode source, EclipseNode fieldNode) {
+ /*
+ java.util.concurrent.atomic.AtomicReference<ValueType> value = this.fieldName.get();
+ if (value == null) {
+ synchronized (this.fieldName) {
+ value = this.fieldName.get();
+ if (value == null) {
+ value = new java.util.concurrent.atomic.AtomicReference<ValueType>(new ValueType());
+ this.fieldName.set(value);
+ }
+ }
+ }
+ return value.get();
+ */
+
+ FieldDeclaration field = (FieldDeclaration) fieldNode.get();
+ int pS = source.sourceStart, pE = source.sourceEnd;
+ long p = (long)pS << 32 | pE;
+
+ TypeReference componentType = copyType(field.type, source);
+ if (field.type instanceof SingleTypeReference && !(field.type instanceof ArrayTypeReference)) {
+ char[][] newType = TYPE_MAP.get(new String(((SingleTypeReference)field.type).token));
+ if (newType != null) {
+ componentType = new QualifiedTypeReference(newType, poss(source, 3));
+ Eclipse.setGeneratedBy(componentType, source);
+ }
+ }
+
+ Statement[] statements = new Statement[3];
+
+ /* java.util.concurrent.atomic.AtomicReference<ValueType> value = this.fieldName.get(); */ {
+ LocalDeclaration valueDecl = new LocalDeclaration(valueName, pS, pE);
+ Eclipse.setGeneratedBy(valueDecl, source);
+ TypeReference[][] typeParams = AR_PARAMS.clone();
+ typeParams[4] = new TypeReference[] {copyType(componentType, source)};
+ valueDecl.type = new ParameterizedQualifiedTypeReference(AR, typeParams, 0, poss(source, 5));
+ valueDecl.type.sourceStart = pS; valueDecl.type.sourceEnd = pE;
+ Eclipse.setGeneratedBy(valueDecl.type, source);
+
+ MessageSend getter = new MessageSend();
+ Eclipse.setGeneratedBy(getter, source);
+ getter.sourceStart = pS; getter.sourceEnd = pE;
+ getter.selector = new char[] {'g', 'e', 't'};
+ getter.receiver = EclipseHandlerUtil.createFieldAccessor(fieldNode, FieldAccess.ALWAYS_FIELD, source);
+
+ valueDecl.initialization = getter;
+ Eclipse.setGeneratedBy(valueDecl.initialization, source);
+ statements[0] = valueDecl;
+ }
+
+ /*
+ if (value == null) {
+ synchronized (this.fieldName) {
+ value = this.fieldName.get();
+ if (value == null) {
+ value = new java.util.concurrent.atomic.AtomicReference<ValueType>(new ValueType());
+ this.fieldName.set(value);
+ }
+ }
+ }
+ */ {
+ EqualExpression cond = new EqualExpression(
+ new SingleNameReference(valueName, p), new NullLiteral(pS, pE),
+ BinaryExpression.EQUAL_EQUAL);
+ Eclipse.setGeneratedBy(cond.left, source);
+ Eclipse.setGeneratedBy(cond.right, source);
+ Eclipse.setGeneratedBy(cond, source);
+ Block then = new Block(0);
+ Eclipse.setGeneratedBy(then, source);
+ Expression lock = EclipseHandlerUtil.createFieldAccessor(fieldNode, FieldAccess.ALWAYS_FIELD, source);
+ Block inner = new Block(0);
+ Eclipse.setGeneratedBy(inner, source);
+ inner.statements = new Statement[2];
+ /* value = this.fieldName.get(); */ {
+ MessageSend getter = new MessageSend();
+ Eclipse.setGeneratedBy(getter, source);
+ getter.sourceStart = pS; getter.sourceEnd = pE;
+ getter.selector = new char[] {'g', 'e', 't'};
+ getter.receiver = EclipseHandlerUtil.createFieldAccessor(fieldNode, FieldAccess.ALWAYS_FIELD, source);
+ Assignment assign = new Assignment(new SingleNameReference(valueName, p), getter, pE);
+ Eclipse.setGeneratedBy(assign, source);
+ Eclipse.setGeneratedBy(assign.lhs, source);
+ inner.statements[0] = assign;
+ }
+ /* if (value == null) */ {
+ EqualExpression innerCond = new EqualExpression(
+ new SingleNameReference(valueName, p), new NullLiteral(pS, pE),
+ BinaryExpression.EQUAL_EQUAL);
+ Eclipse.setGeneratedBy(innerCond.left, source);
+ Eclipse.setGeneratedBy(innerCond.right, source);
+ Eclipse.setGeneratedBy(innerCond, source);
+ Block innerThen = new Block(0);
+ Eclipse.setGeneratedBy(innerThen, source);
+ innerThen.statements = new Statement[2];
+ /*value = new java.util.concurrent.atomic.AtomicReference<ValueType>(new ValueType()); */ {
+ AllocationExpression create = new AllocationExpression();
+ Eclipse.setGeneratedBy(create, source);
+ create.sourceStart = pS; create.sourceEnd = pE;
+ TypeReference[][] typeParams = AR_PARAMS.clone();
+ typeParams[4] = new TypeReference[] {copyType(componentType, source)};
+ create.type = new ParameterizedQualifiedTypeReference(AR, typeParams, 0, poss(source, 5));
+ create.type.sourceStart = pS; create.type.sourceEnd = pE;
+ Eclipse.setGeneratedBy(create.type, source);
+ create.arguments = new Expression[] {field.initialization};
+ Assignment innerAssign = new Assignment(new SingleNameReference(valueName, p), create, pE);
+ Eclipse.setGeneratedBy(innerAssign, source);
+ Eclipse.setGeneratedBy(innerAssign.lhs, source);
+ innerThen.statements[0] = innerAssign;
+ }
+
+ /*this.fieldName.set(value);*/ {
+ MessageSend setter = new MessageSend();
+ Eclipse.setGeneratedBy(setter, source);
+ setter.sourceStart = pS; setter.sourceEnd = pE;
+ setter.receiver = EclipseHandlerUtil.createFieldAccessor(fieldNode, FieldAccess.ALWAYS_FIELD, source);
+ setter.selector = new char[] { 's', 'e', 't' };
+ setter.arguments = new Expression[] {
+ new SingleNameReference(valueName, p)};
+ Eclipse.setGeneratedBy(setter.arguments[0], source);
+ innerThen.statements[1] = setter;
+ }
+
+ IfStatement innerIf = new IfStatement(innerCond, innerThen, pS, pE);
+ Eclipse.setGeneratedBy(innerIf, source);
+ inner.statements[1] = innerIf;
+ }
+
+ SynchronizedStatement sync = new SynchronizedStatement(lock, inner, pS, pE);
+ Eclipse.setGeneratedBy(sync, source);
+ then.statements = new Statement[] {sync};
+
+ IfStatement ifStatement = new IfStatement(cond, then, pS, pE);
+ Eclipse.setGeneratedBy(ifStatement, source);
+ statements[1] = ifStatement;
+ }
+
+ /* return value.get(); */ {
+ MessageSend getter = new MessageSend();
+ Eclipse.setGeneratedBy(getter, source);
+ getter.sourceStart = pS; getter.sourceEnd = pE;
+ getter.selector = new char[] {'g', 'e', 't'};
+ getter.receiver = new SingleNameReference(valueName, p);
+ Eclipse.setGeneratedBy(getter.receiver, source);
+
+ statements[2] = new ReturnStatement(getter, pS, pE);
+ Eclipse.setGeneratedBy(statements[2], source);
+ }
+
+
+ // update the field type and init last
+
+ /* private final java.util.concurrent.atomic.AtomicReference<java.util.concurrent.atomic.AtomicReference<ValueType> fieldName = new java.util.concurrent.atomic.AtomicReference<java.util.concurrent.atomic.AtomicReference<ValueType>>(); */ {
+
+ LocalDeclaration first = (LocalDeclaration) statements[0];
+ TypeReference innerType = copyType(first.type, source);
+
+ TypeReference[][] typeParams = AR_PARAMS.clone();
+ typeParams[4] = new TypeReference[] {copyType(innerType, source)};
+ TypeReference type = new ParameterizedQualifiedTypeReference(AR, typeParams, 0, poss(source, 5));
+ // Some magic here
+ type.sourceStart = -1; type.sourceEnd = -2;
+ Eclipse.setGeneratedBy(type, source);
+
+ field.type = type;
+ AllocationExpression init = new AllocationExpression();
+ // Some magic here
+ init.sourceStart = field.initialization.sourceStart; init.sourceEnd = field.initialization.sourceEnd;
+ init.type = copyType(type, source);
+ field.initialization = init;
+ }
+ return statements;
+ }
}
generated by cgit (git 2.46.0) at 2024-11-23 21:06:26 +0000