From 39d2c280fbaced63f5697481af6b37ab81891798 Mon Sep 17 00:00:00 2001
From: Roel Spilker <r.spilker@gmail.com>
Date: Thu, 18 Jun 2020 22:08:25 +0200
Subject: Fixes #1543: in equals, by default first compare the primitives

---
 src/core/lombok/EqualsAndHashCode.java               |  4 +++-
 src/core/lombok/core/LombokNode.java                 |  1 +
 .../core/handlers/InclusionExclusionUtils.java       | 18 ++++++++++++------
 src/core/lombok/eclipse/EclipseNode.java             | 19 +++++++++++++++----
 src/core/lombok/eclipse/handlers/HandleBuilder.java  |  2 +-
 .../lombok/eclipse/handlers/HandleSuperBuilder.java  |  2 +-
 src/core/lombok/javac/JavacNode.java                 | 20 +++++++++++++++-----
 src/core/lombok/javac/handlers/HandleBuilder.java    |  2 +-
 .../lombok/javac/handlers/HandleSuperBuilder.java    |  2 +-
 9 files changed, 50 insertions(+), 20 deletions(-)

(limited to 'src')

diff --git a/src/core/lombok/EqualsAndHashCode.java b/src/core/lombok/EqualsAndHashCode.java
index 02596f24..2f53bdec 100644
--- a/src/core/lombok/EqualsAndHashCode.java
+++ b/src/core/lombok/EqualsAndHashCode.java
@@ -125,7 +125,9 @@ public @interface EqualsAndHashCode {
 
 		/**
 		 * 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.
+		 * 
 		 * @return ordering within the generating {@code equals} and {@code hashCode} methods; higher numbers are considered first.
 		 */
 		int rank() default 0;
diff --git a/src/core/lombok/core/LombokNode.java b/src/core/lombok/core/LombokNode.java
index e52cd5b3..46054077 100644
--- a/src/core/lombok/core/LombokNode.java
+++ b/src/core/lombok/core/LombokNode.java
@@ -288,6 +288,7 @@ public abstract class LombokNode<A extends AST<A, L, N>, L extends LombokNode<A,
 	public abstract boolean isStatic();
 	public abstract boolean isFinal();
 	public abstract boolean isTransient();
+	public abstract boolean isPrimitive();
 	public abstract boolean isEnumMember();
 	public abstract boolean isEnumType();
 	
diff --git a/src/core/lombok/core/handlers/InclusionExclusionUtils.java b/src/core/lombok/core/handlers/InclusionExclusionUtils.java
index c50da1cc..609a5e36 100644
--- a/src/core/lombok/core/handlers/InclusionExclusionUtils.java
+++ b/src/core/lombok/core/handlers/InclusionExclusionUtils.java
@@ -76,11 +76,13 @@ public class InclusionExclusionUtils {
 		private final L node;
 		private final I inc;
 		private final boolean defaultInclude;
+		private final boolean explicitRank;
 		
-		public Included(L node, I inc, boolean defaultInclude) {
+		public Included(L node, I inc, boolean defaultInclude, boolean explicitRank) {
 			this.node = node;
 			this.inc = inc;
 			this.defaultInclude = defaultInclude;
+			this.explicitRank = explicitRank;
 		}
 		
 		public L getNode() {
@@ -94,6 +96,10 @@ public class InclusionExclusionUtils {
 		public boolean isDefaultInclude() {
 			return defaultInclude;
 		}
+		
+		public boolean hasExplicitRank() {
+			return explicitRank;
+		}
 	}
 	
 	private static String innerAnnName(Class<? extends Annotation> type) {
@@ -164,13 +170,13 @@ public class InclusionExclusionUtils {
 					if (n.isEmpty()) n = name;
 					namesToAutoExclude.add(n);
 				}
-				members.add(new Included<L, I>(child, inc, false));
+				members.add(new Included<L, I>(child, inc, false, markInclude.isExplicit("rank")));
 				continue;
 			}
 			
 			if (onlyExplicitlyIncluded) continue;
 			if (oldIncludes != null) {
-				if (child.getKind() == Kind.FIELD && oldIncludes.contains(name)) members.add(new Included<L, I>(child, null, false));
+				if (child.getKind() == Kind.FIELD && oldIncludes.contains(name)) members.add(new Included<L, I>(child, null, false, false));
 				continue;
 			}
 			if (child.getKind() != Kind.FIELD) continue;
@@ -178,7 +184,7 @@ public class InclusionExclusionUtils {
 			if (child.isTransient() && !includeTransient) continue;
 			if (name.startsWith("$")) continue;
 			if (child.isEnumMember()) continue;
-			members.add(new Included<L, I>(child, null, true));
+			members.add(new Included<L, I>(child, null, true, false));
 		}
 		
 		/* delete default-included fields with the same name as an explicit inclusion */ {
@@ -219,8 +225,8 @@ public class InclusionExclusionUtils {
 
 		Collections.sort(members, new Comparator<Included<L, EqualsAndHashCode.Include>>() {
 			@Override public int compare(Included<L, EqualsAndHashCode.Include> a, Included<L, EqualsAndHashCode.Include> b) {
-				int ra = a.getInc() == null ? 0 : a.getInc().rank();
-				int rb = b.getInc() == null ? 0 : b.getInc().rank();
+				int ra = a.hasExplicitRank() ? a.getInc().rank() : a.node.isPrimitive() ? 1000 : 0;
+				int rb = b.hasExplicitRank() ? b.getInc().rank() : b.node.isPrimitive() ? 1000 : 0;
 
 				return compareRankOrPosition(ra, rb, a.getNode(), b.getNode());
 			}
diff --git a/src/core/lombok/eclipse/EclipseNode.java b/src/core/lombok/eclipse/EclipseNode.java
index 9db491f5..5aa29466 100644
--- a/src/core/lombok/eclipse/EclipseNode.java
+++ b/src/core/lombok/eclipse/EclipseNode.java
@@ -23,10 +23,6 @@ package lombok.eclipse;
 
 import java.util.List;
 
-import lombok.core.AnnotationValues;
-import lombok.core.AST.Kind;
-import lombok.eclipse.handlers.EclipseHandlerUtil;
-
 import org.eclipse.jdt.internal.compiler.ast.ASTNode;
 import org.eclipse.jdt.internal.compiler.ast.AbstractMethodDeclaration;
 import org.eclipse.jdt.internal.compiler.ast.Annotation;
@@ -36,11 +32,16 @@ import org.eclipse.jdt.internal.compiler.ast.CompilationUnitDeclaration;
 import org.eclipse.jdt.internal.compiler.ast.FieldDeclaration;
 import org.eclipse.jdt.internal.compiler.ast.Initializer;
 import org.eclipse.jdt.internal.compiler.ast.LocalDeclaration;
+import org.eclipse.jdt.internal.compiler.ast.MethodDeclaration;
 import org.eclipse.jdt.internal.compiler.ast.Statement;
 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 lombok.core.AST.Kind;
+import lombok.core.AnnotationValues;
+import lombok.eclipse.handlers.EclipseHandlerUtil;
+
 /**
  * Eclipse specific version of the LombokNode class.
  */
@@ -264,6 +265,16 @@ public class EclipseNode extends lombok.core.LombokNode<EclipseAST, EclipseNode,
 		return (ClassFileConstants.AccFinal & f) != 0;
 	}
 	
+	@Override public boolean isPrimitive() {
+		if (node instanceof FieldDeclaration && !isEnumMember()) {
+			return Eclipse.isPrimitive(((FieldDeclaration) node).type);
+		}
+		if (node instanceof MethodDeclaration) {
+			return Eclipse.isPrimitive(((MethodDeclaration) node).returnType);
+		}
+		return false;
+	}
+	
 	@Override public boolean isTransient() {
 		if (getKind() != Kind.FIELD) return false;
 		Integer i = getModifiers();
diff --git a/src/core/lombok/eclipse/handlers/HandleBuilder.java b/src/core/lombok/eclipse/handlers/HandleBuilder.java
index b8e88522..f848469f 100755
--- a/src/core/lombok/eclipse/handlers/HandleBuilder.java
+++ b/src/core/lombok/eclipse/handlers/HandleBuilder.java
@@ -485,7 +485,7 @@ public class HandleBuilder extends EclipseAnnotationHandler<Builder> {
 			List<Included<EclipseNode, ToString.Include>> fieldNodes = new ArrayList<Included<EclipseNode, ToString.Include>>();
 			for (BuilderFieldData bfd : builderFields) {
 				for (EclipseNode f : bfd.createdFields) {
-					fieldNodes.add(new Included<EclipseNode, ToString.Include>(f, null, true));
+					fieldNodes.add(new Included<EclipseNode, ToString.Include>(f, null, true, false));
 				}
 			}
 			MethodDeclaration md = HandleToString.createToString(builderType, fieldNodes, true, false, ast, FieldAccess.ALWAYS_FIELD);
diff --git a/src/core/lombok/eclipse/handlers/HandleSuperBuilder.java b/src/core/lombok/eclipse/handlers/HandleSuperBuilder.java
index 7c8e4ea3..cc4d55be 100644
--- a/src/core/lombok/eclipse/handlers/HandleSuperBuilder.java
+++ b/src/core/lombok/eclipse/handlers/HandleSuperBuilder.java
@@ -354,7 +354,7 @@ public class HandleSuperBuilder extends EclipseAnnotationHandler<SuperBuilder> {
 			List<Included<EclipseNode, ToString.Include>> fieldNodes = new ArrayList<Included<EclipseNode, ToString.Include>>();
 			for (BuilderFieldData bfd : builderFields) {
 				for (EclipseNode f : bfd.createdFields) {
-					fieldNodes.add(new Included<EclipseNode, ToString.Include>(f, null, true));
+					fieldNodes.add(new Included<EclipseNode, ToString.Include>(f, null, true, false));
 				}
 			}
 			// Let toString() call super.toString() if there is a superclass, so that it also shows fields from the superclass' builder.
diff --git a/src/core/lombok/javac/JavacNode.java b/src/core/lombok/javac/JavacNode.java
index 19bbeae3..08d22d98 100644
--- a/src/core/lombok/javac/JavacNode.java
+++ b/src/core/lombok/javac/JavacNode.java
@@ -27,10 +27,6 @@ import java.util.List;
 import javax.lang.model.element.Element;
 import javax.tools.Diagnostic;
 
-import lombok.core.AnnotationValues;
-import lombok.core.AST.Kind;
-import lombok.javac.handlers.JavacHandlerUtil;
-
 import com.sun.tools.javac.code.Flags;
 import com.sun.tools.javac.code.Symtab;
 import com.sun.tools.javac.model.JavacTypes;
@@ -43,8 +39,12 @@ import com.sun.tools.javac.tree.JCTree.JCMethodDecl;
 import com.sun.tools.javac.tree.JCTree.JCModifiers;
 import com.sun.tools.javac.tree.JCTree.JCVariableDecl;
 import com.sun.tools.javac.util.Context;
-import com.sun.tools.javac.util.Name;
 import com.sun.tools.javac.util.JCDiagnostic.DiagnosticPosition;
+import com.sun.tools.javac.util.Name;
+
+import lombok.core.AST.Kind;
+import lombok.core.AnnotationValues;
+import lombok.javac.handlers.JavacHandlerUtil;
 
 /**
  * Javac specific version of the LombokNode class.
@@ -345,6 +345,16 @@ public class JavacNode extends lombok.core.LombokNode<JavacAST, JavacNode, JCTre
 		return mods != null && (Flags.ENUM & mods.flags) != 0;
 	}
 	
+	@Override public boolean isPrimitive() {
+		if (node instanceof JCVariableDecl && !isEnumMember()) {
+			return Javac.isPrimitive(((JCVariableDecl) node).vartype);
+		}
+		if (node instanceof JCMethodDecl) {
+			return Javac.isPrimitive(((JCMethodDecl) node).restype);
+		}
+		return false;
+	}
+	
 	@Override public boolean isTransient() {
 		if (getKind() != Kind.FIELD) return false;
 		JCModifiers mods = getModifiers();
diff --git a/src/core/lombok/javac/handlers/HandleBuilder.java b/src/core/lombok/javac/handlers/HandleBuilder.java
index 95be28f3..7e87ce11 100644
--- a/src/core/lombok/javac/handlers/HandleBuilder.java
+++ b/src/core/lombok/javac/handlers/HandleBuilder.java
@@ -435,7 +435,7 @@ public class HandleBuilder extends JavacAnnotationHandler<Builder> {
 			java.util.List<Included<JavacNode, ToString.Include>> fieldNodes = new ArrayList<Included<JavacNode, ToString.Include>>();
 			for (BuilderFieldData bfd : builderFields) {
 				for (JavacNode f : bfd.createdFields) {
-					fieldNodes.add(new Included<JavacNode, ToString.Include>(f, null, true));
+					fieldNodes.add(new Included<JavacNode, ToString.Include>(f, null, true, false));
 				}
 			}
 			
diff --git a/src/core/lombok/javac/handlers/HandleSuperBuilder.java b/src/core/lombok/javac/handlers/HandleSuperBuilder.java
index 4cd64b77..f6bf9e1f 100644
--- a/src/core/lombok/javac/handlers/HandleSuperBuilder.java
+++ b/src/core/lombok/javac/handlers/HandleSuperBuilder.java
@@ -304,7 +304,7 @@ public class HandleSuperBuilder extends JavacAnnotationHandler<SuperBuilder> {
 		java.util.List<Included<JavacNode, ToString.Include>> fieldNodes = new ArrayList<Included<JavacNode, ToString.Include>>();
 		for (BuilderFieldData bfd : builderFields) {
 			for (JavacNode f : bfd.createdFields) {
-				fieldNodes.add(new Included<JavacNode, ToString.Include>(f, null, true));
+				fieldNodes.add(new Included<JavacNode, ToString.Include>(f, null, true, false));
 			}
 		}
 		
-- 
cgit