aboutsummaryrefslogtreecommitdiff
path: root/src/core/lombok
diff options
context:
space:
mode:
Diffstat (limited to 'src/core/lombok')
-rw-r--r--src/core/lombok/EqualsAndHashCode.java139
-rwxr-xr-xsrc/core/lombok/eclipse/handlers/HandleEqualsAndHashCode.java77
-rw-r--r--src/core/lombok/javac/handlers/HandleEqualsAndHashCode.java38
3 files changed, 183 insertions, 71 deletions
diff --git a/src/core/lombok/EqualsAndHashCode.java b/src/core/lombok/EqualsAndHashCode.java
index d73afe13..7f60880c 100644
--- a/src/core/lombok/EqualsAndHashCode.java
+++ b/src/core/lombok/EqualsAndHashCode.java
@@ -27,18 +27,21 @@ import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
- * Generates implementations for the {@code equals} and {@code hashCode} methods inherited by all objects, based on relevant fields.
+ * Generates implementations for the {@code equals} and {@code hashCode} methods
+ * inherited by all objects, based on relevant fields.
* <p>
- * Complete documentation is found at <a href="https://projectlombok.org/features/EqualsAndHashCode">the project lombok features page for &#64;EqualsAndHashCode</a>.
+ * Complete documentation is found at
+ * <a href="https://projectlombok.org/features/EqualsAndHashCode">the project
+ * lombok features page for &#64;EqualsAndHashCode</a>.
*/
-@Target(ElementType.TYPE)
-@Retention(RetentionPolicy.SOURCE)
-public @interface EqualsAndHashCode {
+@Target(ElementType.TYPE) @Retention(RetentionPolicy.SOURCE) public @interface EqualsAndHashCode {
/**
- * Any fields listed here will not be taken into account in the generated {@code equals} and {@code hashCode} implementations.
- * Mutually exclusive with {@link #of()}.
+ * Any fields listed here will not be taken into account in the generated
+ * {@code equals} and {@code hashCode} implementations. Mutually exclusive
+ * with {@link #of()}.
* <p>
- * Will soon be marked {@code @Deprecated}; use the {@code @EqualsAndHashCode.Exclude} annotation instead.
+ * Will soon be marked {@code @Deprecated}; use the
+ * {@code @EqualsAndHashCode.Exclude} annotation instead.
*
* @return A list of fields to exclude.
*/
@@ -50,97 +53,129 @@ public @interface EqualsAndHashCode {
* <p>
* Mutually exclusive with {@link #exclude()}.
* <p>
- * Will soon be marked {@code @Deprecated}; use the {@code @EqualsAndHashCode.Include} annotation together with {@code @EqualsAndHashCode(onlyExplicitlyIncluded = true)}.
+ * Will soon be marked {@code @Deprecated}; use the
+ * {@code @EqualsAndHashCode.Include} annotation together with
+ * {@code @EqualsAndHashCode(onlyExplicitlyIncluded = true)}.
*
* @return A list of fields to use (<em>default</em>: all of them).
*/
String[] of() default {};
/**
- * Call on the superclass's implementations of {@code equals} and {@code hashCode} before calculating for the fields in this class.
+ * Call on the superclass's implementations of {@code equals} and
+ * {@code hashCode} before calculating for the fields in this class.
* <strong>default: false</strong>
*
- * @return Whether to call the superclass's {@code equals} implementation as part of the generated equals algorithm.
+ * @return Whether to call the superclass's {@code equals} implementation as
+ * part of the generated equals algorithm.
*/
boolean callSuper() default false;
/**
- * Normally, if getters are available, those are called. To suppress this and let the generated code use the fields directly, set this to {@code true}.
- * <strong>default: false</strong>
+ * Normally, if getters are available, those are called. To suppress this
+ * and let the generated code use the fields directly, set this to
+ * {@code true}. <strong>default: false</strong>
*
- * @return If {@code true}, always use direct field access instead of calling the getter method.
+ * @return If {@code true}, always use direct field access instead of
+ * calling the getter method.
*/
boolean doNotUseGetters() default false;
-
+
/**
- * Enables caching the result of {@code hashCode}.
- * This is useful to prevent running expensive calculations of {@code hashCode} multiple times for fully immutable objects, where it would always return the same result.
- * It is similar to what {@link java.lang.String#hashCode} does.
- * This should only be used for fully immutable classes (classes with all-immutable fields).
- * <strong>default: false</strong>
+ * Determines how the result of the {@code hashCode} method will be cached.
+ * <strong>default: {@link CacheStrategy#NEVER}</strong>
*
- * @return If {@code true}, cache the result of {@code hashCode} to avoid recalculating it in future invocations.
+ * @return The {@code hashCode} cache strategy to be used.
*/
- boolean cacheHashCode() default false;
+ CacheStrategy cacheStrategy() default CacheStrategy.NEVER;
/**
- * Any annotations listed here are put on the generated parameter of {@code equals} and {@code canEqual}.
- * This is useful to add for example a {@code Nullable} annotation.<br>
- * The syntax for this feature depends on JDK version (nothing we can do about that; it's to work around javac bugs).<br>
+ * Any annotations listed here are put on the generated parameter of
+ * {@code equals} and {@code canEqual}. This is useful to add for example a
+ * {@code Nullable} annotation.<br>
+ * The syntax for this feature depends on JDK version (nothing we can do
+ * about that; it's to work around javac bugs).<br>
* up to JDK7:<br>
- * {@code @EqualsAndHashCode(onParam=@__({@AnnotationsGoHere}))}<br>
+ * {@code @EqualsAndHashCode(onParam=@__({@AnnotationsGoHere}))}<br>
* from JDK8:<br>
- * {@code @EqualsAndHashCode(onParam_={@AnnotationsGohere})} // note the underscore after {@code onParam}.
- *
- * @return List of annotations to apply to the generated parameter in the {@code equals()} method.
+ * {@code @EqualsAndHashCode(onParam_={@AnnotationsGohere})} // note the
+ * underscore after {@code onParam}.
+ *
+ * @return List of annotations to apply to the generated parameter in the
+ * {@code equals()} method.
*/
AnyAnnotation[] onParam() default {};
/**
- * Placeholder annotation to enable the placement of annotations on the generated code.
+ * Placeholder annotation to enable the placement of annotations on the
+ * generated code.
+ *
* @deprecated Don't use this annotation, ever - Read the documentation.
*/
- @Deprecated
- @Retention(RetentionPolicy.SOURCE)
- @Target({})
- @interface AnyAnnotation {}
+ @Deprecated @Retention(RetentionPolicy.SOURCE) @Target({})
+ @interface AnyAnnotation {
+ }
/**
- * Only include fields and methods explicitly marked with {@code @EqualsAndHashCode.Include}.
- * Normally, all (non-static, non-transient) fields are included by default.
+ * Only include fields and methods explicitly marked with
+ * {@code @EqualsAndHashCode.Include}. Normally, all (non-static,
+ * non-transient) fields are included by default.
*
- * @return If {@code true}, don't include non-static non-transient fields automatically (default: {@code false}).
+ * @return If {@code true}, don't include non-static non-transient fields
+ * automatically (default: {@code false}).
*/
boolean onlyExplicitlyIncluded() default false;
/**
- * If present, do not include this field in the generated {@code equals} and {@code hashCode} methods.
+ * If present, do not include this field in the generated {@code equals} and
+ * {@code hashCode} methods.
*/
- @Target(ElementType.FIELD)
- @Retention(RetentionPolicy.SOURCE)
- public @interface Exclude {}
+ @Target(ElementType.FIELD) @Retention(RetentionPolicy.SOURCE) public @interface Exclude {
+ }
/**
- * Configure the behaviour of how this member is treated in the {@code equals} and {@code hashCode} implementation; if on a method, include the method's return value as part of calculating hashCode/equality.
+ * Configure the behaviour of how this member is treated in the
+ * {@code equals} and {@code hashCode} implementation; if on a method,
+ * include the method's return value as part of calculating
+ * hashCode/equality.
*/
- @Target({ElementType.FIELD, ElementType.METHOD})
- @Retention(RetentionPolicy.SOURCE)
- public @interface Include {
+ @Target({ElementType.FIELD, ElementType.METHOD}) @Retention(RetentionPolicy.SOURCE) public @interface Include {
/**
- * Defaults to the method name of the annotated member.
- * If on a method and the name equals the name of a default-included field, this member takes its place.
+ * Defaults to the method name of the annotated member. If on a method
+ * and the name equals the name of a default-included field, this member
+ * takes its place.
*
- * @return If present, this method serves as replacement for the named field.
+ * @return If present, this method serves as replacement for the named
+ * field.
*/
String replaces() default "";
-
+
/**
- * Higher ranks are considered first. Members of the same rank are considered in the order they appear in the source file.
+ * Higher ranks are considered first. Members of the same rank are
+ * considered in the order they appear in the source file.
*
- * If not explicitly set, the {@code default} rank for primitives is 1000, and for primitive wrappers 800.
+ * If not explicitly set, the {@code default} rank for primitives is
+ * 1000, and for primitive wrappers 800.
*
- * @return ordering within the generating {@code equals} and {@code hashCode} methods; higher numbers are considered first.
+ * @return ordering within the generating {@code equals} and
+ * {@code hashCode} methods; higher numbers are considered
+ * first.
*/
int rank() default 0;
}
+
+ public enum CacheStrategy {
+ /**
+ * Never cache. Perform the calculation every time the method is called.
+ */
+ NEVER,
+ /**
+ * Cache the result of the first invocation of {@code hashCode} and use it for subsequent invocations.
+ * This can improve performance in if all fields used for calculating the {@code hashCode} are immutable
+ * and thus every invocation of {@code hashCode} will always return the same value.
+ * <strong>Do not use this if there's <em>any</em> chance that different invocations of {@code hashCode}
+ * might return different values.</strong>
+ */
+ LAZY
+ }
}
diff --git a/src/core/lombok/eclipse/handlers/HandleEqualsAndHashCode.java b/src/core/lombok/eclipse/handlers/HandleEqualsAndHashCode.java
index 7147343e..76a46814 100755
--- a/src/core/lombok/eclipse/handlers/HandleEqualsAndHashCode.java
+++ b/src/core/lombok/eclipse/handlers/HandleEqualsAndHashCode.java
@@ -36,6 +36,7 @@ import java.util.Set;
import lombok.AccessLevel;
import lombok.ConfigurationKeys;
import lombok.EqualsAndHashCode;
+import lombok.EqualsAndHashCode.CacheStrategy;
import lombok.core.AST.Kind;
import lombok.core.handlers.HandlerUtil;
import lombok.core.handlers.InclusionExclusionUtils;
@@ -47,6 +48,7 @@ import lombok.eclipse.Eclipse;
import lombok.eclipse.EclipseAnnotationHandler;
import lombok.eclipse.EclipseNode;
import lombok.eclipse.handlers.EclipseHandlerUtil.MemberExistsResult;
+import lombok.javac.JavacTreeMaker;
import org.eclipse.jdt.internal.compiler.ast.ASTNode;
import org.eclipse.jdt.internal.compiler.ast.Annotation;
@@ -59,9 +61,11 @@ import org.eclipse.jdt.internal.compiler.ast.ConditionalExpression;
import org.eclipse.jdt.internal.compiler.ast.EqualExpression;
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.IfStatement;
import org.eclipse.jdt.internal.compiler.ast.InstanceOfExpression;
import org.eclipse.jdt.internal.compiler.ast.IntLiteral;
+import org.eclipse.jdt.internal.compiler.ast.IntLiteralMinValue;
import org.eclipse.jdt.internal.compiler.ast.LocalDeclaration;
import org.eclipse.jdt.internal.compiler.ast.MarkerAnnotation;
import org.eclipse.jdt.internal.compiler.ast.MessageSend;
@@ -76,6 +80,7 @@ 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.SuperReference;
import org.eclipse.jdt.internal.compiler.ast.ThisReference;
import org.eclipse.jdt.internal.compiler.ast.TrueLiteral;
@@ -84,16 +89,24 @@ import org.eclipse.jdt.internal.compiler.ast.TypeReference;
import org.eclipse.jdt.internal.compiler.ast.UnaryExpression;
import org.eclipse.jdt.internal.compiler.ast.Wildcard;
import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;
+import org.eclipse.jdt.internal.compiler.lookup.MethodScope;
import org.eclipse.jdt.internal.compiler.lookup.TypeConstants;
import org.eclipse.jdt.internal.compiler.lookup.TypeIds;
import org.mangosdk.spi.ProviderFor;
+import com.sun.tools.javac.code.Flags;
+import com.sun.tools.javac.tree.JCTree.JCModifiers;
+import com.sun.tools.javac.tree.JCTree.JCVariableDecl;
+
/**
* Handles the {@code EqualsAndHashCode} annotation for eclipse.
*/
@ProviderFor(EclipseAnnotationHandler.class)
public class HandleEqualsAndHashCode extends EclipseAnnotationHandler<EqualsAndHashCode> {
+ private static final String HASH_CODE_CACHE_NAME = "$hashCodeCache";
+
+ private final char[] HASH_CODE_CACHE_NAME_ARR = HASH_CODE_CACHE_NAME.toCharArray();
private final char[] PRIME = "PRIME".toCharArray();
private final char[] RESULT = "result".toCharArray();
@@ -116,7 +129,9 @@ public class HandleEqualsAndHashCode extends EclipseAnnotationHandler<EqualsAndH
boolean doNotUseGetters = annotation.isExplicit("doNotUseGetters") || doNotUseGettersConfiguration == null ? ann.doNotUseGetters() : doNotUseGettersConfiguration;
FieldAccess fieldAccess = doNotUseGetters ? FieldAccess.PREFER_FIELD : FieldAccess.GETTER;
- generateMethods(annotationNode.up(), annotationNode, members, callSuper, true, fieldAccess, onParam);
+ boolean cacheHashCode = ann.cacheStrategy() == CacheStrategy.LAZY;
+
+ generateMethods(annotationNode.up(), annotationNode, members, callSuper, true, cacheHashCode, fieldAccess, onParam);
}
public void generateEqualsAndHashCodeForType(EclipseNode typeNode, EclipseNode errorNode) {
@@ -130,11 +145,11 @@ public class HandleEqualsAndHashCode extends EclipseAnnotationHandler<EqualsAndH
Boolean doNotUseGettersConfiguration = typeNode.getAst().readConfiguration(ConfigurationKeys.EQUALS_AND_HASH_CODE_DO_NOT_USE_GETTERS);
FieldAccess access = doNotUseGettersConfiguration == null || !doNotUseGettersConfiguration ? FieldAccess.GETTER : FieldAccess.PREFER_FIELD;
- generateMethods(typeNode, errorNode, members, null, false, access, new ArrayList<Annotation>());
+ generateMethods(typeNode, errorNode, members, null, false, false, access, new ArrayList<Annotation>());
}
public void generateMethods(EclipseNode typeNode, EclipseNode errorNode, List<Included<EclipseNode, EqualsAndHashCode.Include>> members,
- Boolean callSuper, boolean whineIfExists, FieldAccess fieldAccess, List<Annotation> onParam) {
+ Boolean callSuper, boolean whineIfExists, boolean cacheHashCode, FieldAccess fieldAccess, List<Annotation> onParam) {
TypeDeclaration typeDecl = null;
@@ -222,12 +237,38 @@ public class HandleEqualsAndHashCode extends EclipseAnnotationHandler<EqualsAndH
injectMethod(typeNode, canEqualMethod);
}
- MethodDeclaration hashCodeMethod = createHashCode(typeNode, members, callSuper, errorNode.get(), fieldAccess);
+ if (cacheHashCode){
+ if (!isFinal) {
+ String msg = "Not caching the result of hashCode: Annotated type is not final.";
+ errorNode.addWarning(msg);
+ cacheHashCode = false;
+ } else if (fieldExists(HASH_CODE_CACHE_NAME, typeNode) != MemberExistsResult.NOT_EXISTS) {
+ String msg = String.format("Not caching the result of hashCode: A field named %s already exists.", HASH_CODE_CACHE_NAME);
+ errorNode.addWarning(msg);
+ cacheHashCode = false;
+ } else {
+ createHashCodeCacheField(typeNode, errorNode.get());
+ }
+ }
+
+ MethodDeclaration hashCodeMethod = createHashCode(typeNode, members, callSuper, cacheHashCode, errorNode.get(), fieldAccess);
hashCodeMethod.traverse(new SetGeneratedByVisitor(errorNode.get()), ((TypeDeclaration)typeNode.get()).scope);
injectMethod(typeNode, hashCodeMethod);
}
+
+ private void createHashCodeCacheField(EclipseNode typeNode, ASTNode source) {
+ FieldDeclaration hashCodeCacheDecl = new FieldDeclaration(HASH_CODE_CACHE_NAME_ARR, 0, -1);
+ hashCodeCacheDecl.modifiers = ClassFileConstants.AccPrivate | ClassFileConstants.AccTransient;
+ hashCodeCacheDecl.bits |= Eclipse.ECLIPSE_DO_NOT_TOUCH_FLAG;
+ hashCodeCacheDecl.type = TypeReference.baseTypeReference(TypeIds.T_int, 0);
+ hashCodeCacheDecl.declarationSourceEnd = -1;
+ hashCodeCacheDecl.initialization = makeIntLiteral("0".toCharArray(), source);
+ injectFieldAndMarkGenerated(typeNode, hashCodeCacheDecl);
+ setGeneratedBy(hashCodeCacheDecl, source);
+ setGeneratedBy(hashCodeCacheDecl.type, source);
+ }
- public MethodDeclaration createHashCode(EclipseNode type, Collection<Included<EclipseNode, EqualsAndHashCode.Include>> members, boolean callSuper, ASTNode source, FieldAccess fieldAccess) {
+ public MethodDeclaration createHashCode(EclipseNode type, Collection<Included<EclipseNode, EqualsAndHashCode.Include>> members, boolean callSuper, boolean cacheHashCode, ASTNode source, FieldAccess fieldAccess) {
int pS = source.sourceStart, pE = source.sourceEnd;
long p = (long) pS << 32 | pE;
@@ -262,6 +303,20 @@ public class HandleEqualsAndHashCode extends EclipseAnnotationHandler<EqualsAndH
}
}
+ /* if ($hashCodeCache != 0) return $hashCodeCache; */ {
+ if (cacheHashCode) {
+ SingleNameReference hashCodeCacheRef = new SingleNameReference(HASH_CODE_CACHE_NAME_ARR, p);
+ setGeneratedBy(hashCodeCacheRef, source);
+ EqualExpression cacheNotZero = new EqualExpression(hashCodeCacheRef, makeIntLiteral("0".toCharArray(), source), OperatorIds.NOT_EQUAL);
+ setGeneratedBy(cacheNotZero, source);
+ ReturnStatement returnCache = new ReturnStatement(hashCodeCacheRef, pS, pS);
+ setGeneratedBy(returnCache, source);
+ IfStatement ifStatement = new IfStatement(cacheNotZero, returnCache, pS, pE);
+ setGeneratedBy(ifStatement, source);
+ statements.add(ifStatement);
+ }
+ }
+
/* final int PRIME = X; */ {
/* Without members, PRIME isn't used, as that would trigger a 'local variable not used' warning. */
if (!isEmpty) {
@@ -391,6 +446,18 @@ public class HandleEqualsAndHashCode extends EclipseAnnotationHandler<EqualsAndH
}
}
+ /* $hashCodeCache = result; */ {
+ if (cacheHashCode) {
+ SingleNameReference hashCodeCacheRef = new SingleNameReference(HASH_CODE_CACHE_NAME_ARR, p);
+ setGeneratedBy(hashCodeCacheRef, source);
+ SingleNameReference resultRef = new SingleNameReference(RESULT, p);
+ setGeneratedBy(resultRef, source);
+ Assignment cacheResult = new Assignment(hashCodeCacheRef, resultRef, pE);
+ setGeneratedBy(cacheResult, source);
+ statements.add(cacheResult);
+ }
+ }
+
/* return result; */ {
SingleNameReference resultRef = new SingleNameReference(RESULT, p);
setGeneratedBy(resultRef, source);
diff --git a/src/core/lombok/javac/handlers/HandleEqualsAndHashCode.java b/src/core/lombok/javac/handlers/HandleEqualsAndHashCode.java
index 6c3eccf4..19f6d750 100644
--- a/src/core/lombok/javac/handlers/HandleEqualsAndHashCode.java
+++ b/src/core/lombok/javac/handlers/HandleEqualsAndHashCode.java
@@ -56,6 +56,7 @@ import com.sun.tools.javac.util.Name;
import lombok.ConfigurationKeys;
import lombok.EqualsAndHashCode;
+import lombok.EqualsAndHashCode.CacheStrategy;
import lombok.core.AST.Kind;
import lombok.core.AnnotationValues;
import lombok.core.configuration.CallSuperType;
@@ -94,7 +95,7 @@ public class HandleEqualsAndHashCode extends JavacAnnotationHandler<EqualsAndHas
boolean doNotUseGetters = annotation.isExplicit("doNotUseGetters") || doNotUseGettersConfiguration == null ? ann.doNotUseGetters() : doNotUseGettersConfiguration;
FieldAccess fieldAccess = doNotUseGetters ? FieldAccess.PREFER_FIELD : FieldAccess.GETTER;
- boolean cacheHashCode = ann.cacheHashCode();
+ boolean cacheHashCode = ann.cacheStrategy() == CacheStrategy.LAZY;
generateMethods(typeNode, annotationNode, members, callSuper, true, cacheHashCode, fieldAccess, onParam);
}
@@ -209,17 +210,21 @@ public class HandleEqualsAndHashCode extends JavacAnnotationHandler<EqualsAndHas
source.addWarning(msg);
cacheHashCode = false;
} else {
- JavacTreeMaker maker = typeNode.getTreeMaker();
- JCModifiers mods = maker.Modifiers(Flags.PRIVATE | Flags.TRANSIENT);
- JCVariableDecl hashCodeCacheField = maker.VarDef(mods, typeNode.toName(HASH_CODE_CACHE_NAME), maker.TypeIdent(CTC_INT), maker.Literal(CTC_INT, 0));
- injectFieldAndMarkGenerated(typeNode, hashCodeCacheField);
- recursiveSetGeneratedBy(hashCodeCacheField, source.get(), typeNode.getContext());
+ createHashCodeCacheField(typeNode, source.get());
}
}
JCMethodDecl hashCodeMethod = createHashCode(typeNode, members, callSuper, cacheHashCode, fieldAccess, source.get());
injectMethod(typeNode, hashCodeMethod);
}
+
+ private void createHashCodeCacheField(JavacNode typeNode, JCTree source) {
+ JavacTreeMaker maker = typeNode.getTreeMaker();
+ JCModifiers mods = maker.Modifiers(Flags.PRIVATE | Flags.TRANSIENT);
+ JCVariableDecl hashCodeCacheField = maker.VarDef(mods, typeNode.toName(HASH_CODE_CACHE_NAME), maker.TypeIdent(CTC_INT), maker.Literal(CTC_INT, 0));
+ injectFieldAndMarkGenerated(typeNode, hashCodeCacheField);
+ recursiveSetGeneratedBy(hashCodeCacheField, source, typeNode.getContext());
+ }
public JCMethodDecl createHashCode(JavacNode typeNode, java.util.List<Included<JavacNode, EqualsAndHashCode.Include>> members, boolean callSuper, boolean cacheHashCode, FieldAccess fieldAccess, JCTree source) {
JavacTreeMaker maker = typeNode.getTreeMaker();
@@ -233,18 +238,20 @@ public class HandleEqualsAndHashCode extends JavacAnnotationHandler<EqualsAndHas
JCExpression returnType = maker.TypeIdent(CTC_INT);
ListBuffer<JCStatement> statements = new ListBuffer<JCStatement>();
- Name cacheHashCodeName = typeNode.toName(HASH_CODE_CACHE_NAME);
- if (cacheHashCode) {
- JCExpression cacheNotZero = maker.Binary(CTC_NOT_EQUAL, maker.Ident(cacheHashCodeName), maker.Literal(CTC_INT, 0));
- statements.append(maker.If(cacheNotZero, maker.Return(maker.Ident(cacheHashCodeName)), null));
- }
-
Name primeName = typeNode.toName(PRIME_NAME);
Name resultName = typeNode.toName(RESULT_NAME);
long finalFlag = JavacHandlerUtil.addFinalIfNeeded(0L, typeNode.getContext());
boolean isEmpty = members.isEmpty();
+ /* if ($hashCodeCache != 0) return $hashCodeCache; */ {
+ if (cacheHashCode) {
+ Name cacheHashCodeName = typeNode.toName(HASH_CODE_CACHE_NAME);
+ JCExpression cacheNotZero = maker.Binary(CTC_NOT_EQUAL, maker.Ident(cacheHashCodeName), maker.Literal(CTC_INT, 0));
+ statements.append(maker.If(cacheNotZero, maker.Return(maker.Ident(cacheHashCodeName)), null));
+ }
+ }
+
/* final int PRIME = X; */ {
if (!isEmpty) {
statements.append(maker.VarDef(maker.Modifiers(finalFlag), primeName, maker.TypeIdent(CTC_INT), maker.Literal(HandlerUtil.primeForHashcode())));
@@ -334,8 +341,11 @@ public class HandleEqualsAndHashCode extends JavacAnnotationHandler<EqualsAndHas
}
}
- if (cacheHashCode) {
- statements.append(maker.Exec(maker.Assign(maker.Ident(cacheHashCodeName), maker.Ident(resultName))));
+ /* $hashCodeCache = result; */ {
+ if (cacheHashCode) {
+ Name cacheHashCodeName = typeNode.toName(HASH_CODE_CACHE_NAME);
+ statements.append(maker.Exec(maker.Assign(maker.Ident(cacheHashCodeName), maker.Ident(resultName))));
+ }
}
/* return result; */ {
generated by cgit (git 2.46.0) at 2024-12-11 11:35:56 +0000