From eac764691b2ebeaae69fbb2e1c808ed7d88eb9ee Mon Sep 17 00:00:00 2001
From: Rawi01 <Rawi01@users.noreply.github.com>
Date: Sat, 29 Apr 2023 10:59:04 +0200
Subject: [PATCH] Refactor reflective type annotation handling

---
 .../handlers/HandleEqualsAndHashCode.java     | 39 +++-----------
 .../javac/handlers/JavacHandlerUtil.java      | 52 +++++++++----------
 2 files changed, 32 insertions(+), 59 deletions(-)

diff --git a/src/core/lombok/javac/handlers/HandleEqualsAndHashCode.java b/src/core/lombok/javac/handlers/HandleEqualsAndHashCode.java
index 3b408145..259880fa 100644
--- a/src/core/lombok/javac/handlers/HandleEqualsAndHashCode.java
+++ b/src/core/lombok/javac/handlers/HandleEqualsAndHashCode.java
@@ -25,7 +25,6 @@ import static lombok.core.handlers.HandlerUtil.handleFlagUsage;
 import static lombok.javac.Javac.*;
 import static lombok.javac.handlers.JavacHandlerUtil.*;
 
-import java.lang.reflect.Field;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collections;
@@ -269,7 +268,7 @@ public class HandleEqualsAndHashCode extends JavacAnnotationHandler<EqualsAndHas
 		
 		for (Included<JavacNode, EqualsAndHashCode.Include> member : members) {
 			JavacNode memberNode = member.getNode();
-			JCExpression fType = unnotate(getFieldType(memberNode, fieldAccess));
+			JCExpression fType = removeTypeUseAnnotations(getFieldType(memberNode, fieldAccess));
 			boolean isMethod = memberNode.getKind() == Kind.METHOD;
 			
 			JCExpression fieldAccessor = isMethod ? createMethodAccessor(maker, memberNode) : createFieldAccessor(maker, memberNode, fieldAccess);
@@ -316,8 +315,8 @@ public class HandleEqualsAndHashCode extends JavacAnnotationHandler<EqualsAndHas
 			} else if (fType instanceof JCArrayTypeTree) {
 				JCArrayTypeTree array = (JCArrayTypeTree) fType;
 				/* java.util.Arrays.deepHashCode(this.fieldName) //use just hashCode() for primitive arrays. */
-				boolean multiDim = unnotate(array.elemtype) instanceof JCArrayTypeTree;
-				boolean primitiveArray = unnotate(array.elemtype) instanceof JCPrimitiveTypeTree;
+				boolean multiDim = removeTypeUseAnnotations(array.elemtype) instanceof JCArrayTypeTree;
+				boolean primitiveArray = removeTypeUseAnnotations(array.elemtype) instanceof JCPrimitiveTypeTree;
 				boolean useDeepHC = multiDim || !primitiveArray;
 				
 				JCExpression hcMethod = chainDots(typeNode, "java", "util", "Arrays", useDeepHC ? "deepHashCode" : "hashCode");
@@ -503,7 +502,7 @@ public class HandleEqualsAndHashCode extends JavacAnnotationHandler<EqualsAndHas
 			JavacNode memberNode = member.getNode();
 			boolean isMethod = memberNode.getKind() == Kind.METHOD;
 			
-			JCExpression fType = unnotate(getFieldType(memberNode, fieldAccess));
+			JCExpression fType = removeTypeUseAnnotations(getFieldType(memberNode, fieldAccess));
 			JCExpression thisFieldAccessor = isMethod ? createMethodAccessor(maker, memberNode) : createFieldAccessor(maker, memberNode, fieldAccess);
 			JCExpression otherFieldAccessor = isMethod ? createMethodAccessor(maker, memberNode, maker.Ident(otherName)) : createFieldAccessor(maker, memberNode, fieldAccess, maker.Ident(otherName));
 			if (fType instanceof JCPrimitiveTypeTree) {
@@ -525,8 +524,8 @@ public class HandleEqualsAndHashCode extends JavacAnnotationHandler<EqualsAndHas
 			} else if (fType instanceof JCArrayTypeTree) {
 				JCArrayTypeTree array = (JCArrayTypeTree) fType;
 				/* if (!java.util.Arrays.deepEquals(this.fieldName, other.fieldName)) return false; //use equals for primitive arrays. */
-				boolean multiDim = unnotate(array.elemtype) instanceof JCArrayTypeTree;
-				boolean primitiveArray = unnotate(array.elemtype) instanceof JCPrimitiveTypeTree;
+				boolean multiDim = removeTypeUseAnnotations(array.elemtype) instanceof JCArrayTypeTree;
+				boolean primitiveArray = removeTypeUseAnnotations(array.elemtype) instanceof JCPrimitiveTypeTree;
 				boolean useDeepEquals = multiDim || !primitiveArray;
 				
 				JCExpression eqMethod = chainDots(typeNode, "java", "util", "Arrays", useDeepEquals ? "deepEquals" : "equals");
@@ -603,30 +602,4 @@ public class HandleEqualsAndHashCode extends JavacAnnotationHandler<EqualsAndHas
 	public JCStatement returnBool(JavacTreeMaker maker, boolean bool) {
 		return maker.Return(maker.Literal(CTC_BOOLEAN, bool ? 1 : 0));
 	}
-	
-	private boolean jcAnnotatedTypeInit;
-	private Class<?> jcAnnotatedTypeClass = null;
-	private Field jcAnnotatedTypeUnderlyingTypeField = null;
-	
-	private JCExpression unnotate(JCExpression type) {
-		if (!isJcAnnotatedType(type)) return type;
-		if (jcAnnotatedTypeUnderlyingTypeField == null) return type;
-		try {
-			return (JCExpression) jcAnnotatedTypeUnderlyingTypeField.get(type);
-		} catch (Exception ignore) {}
-		return type;
-	}
-	
-	private boolean isJcAnnotatedType(JCExpression o) {
-		if (o == null) return false;
-		if (!jcAnnotatedTypeInit) {
-			try {
-				jcAnnotatedTypeClass = Class.forName("com.sun.tools.javac.tree.JCTree$JCAnnotatedType", false, o.getClass().getClassLoader());
-				jcAnnotatedTypeUnderlyingTypeField = jcAnnotatedTypeClass.getDeclaredField("underlyingType");
-			}
-			catch (Exception ignore) {}
-			jcAnnotatedTypeInit = true;
-		}
-		return jcAnnotatedTypeClass == o.getClass();
-	}
 }
diff --git a/src/core/lombok/javac/handlers/JavacHandlerUtil.java b/src/core/lombok/javac/handlers/JavacHandlerUtil.java
index 78c7caf5..80228b56 100644
--- a/src/core/lombok/javac/handlers/JavacHandlerUtil.java
+++ b/src/core/lombok/javac/handlers/JavacHandlerUtil.java
@@ -1212,41 +1212,39 @@ public class JavacHandlerUtil {
 	}
 	
 	static class JCAnnotatedTypeReflect {
-		private static Class<?> TYPE;
-		private static Constructor<?> CONSTRUCTOR;
-		private static Field ANNOTATIONS, UNDERLYING_TYPE;
+		private static final Class<?> TYPE;
+		private static final Constructor<?> CONSTRUCTOR;
+		private static final Field ANNOTATIONS, UNDERLYING_TYPE;
 		
-		private static void initByLoader(ClassLoader classLoader) {
-			if (TYPE != null) return;
-			Class<?> c;
+		static {
+			Class<?> t = null;
+			Constructor<?> c = null;
+			Field a = null;
+			Field u = null;
+			
 			try {
-				c = classLoader.loadClass("com.sun.tools.javac.tree.JCTree$JCAnnotatedType");
+				t = Class.forName("com.sun.tools.javac.tree.JCTree$JCAnnotatedType");
+				c = Permit.getConstructor(t, List.class, JCExpression.class);
+				a = Permit.permissiveGetField(t, "annotations");
+				u = Permit.permissiveGetField(t, "underlyingType");
 			} catch (Exception e) {
-				return;
+				// Ignore
 			}
-			init(c);
-		}
-		
-		private static void init(Class<?> in) {
-			if (TYPE != null) return;
-			if (!in.getName().equals("com.sun.tools.javac.tree.JCTree$JCAnnotatedType")) return;
-			try {
-				CONSTRUCTOR = Permit.getConstructor(in, List.class, JCExpression.class);
-				ANNOTATIONS = Permit.getField(in, "annotations");
-				UNDERLYING_TYPE = Permit.getField(in, "underlyingType");
-				TYPE = in;
-			} catch (Exception ignore) {}
+			
+			TYPE = t;
+			CONSTRUCTOR = c;
+			ANNOTATIONS = a;
+			UNDERLYING_TYPE = u;
 		}
 		
 		static boolean is(JCTree obj) {
 			if (obj == null) return false;
-			init(obj.getClass());
 			return obj.getClass() == TYPE;
 		}
 		
 		@SuppressWarnings("unchecked")
 		static List<JCAnnotation> getAnnotations(JCTree obj) {
-			init(obj.getClass());
+			if (ANNOTATIONS == null) return List.nil();
 			try {
 				return (List<JCAnnotation>) ANNOTATIONS.get(obj);
 			} catch (Exception e) {
@@ -1255,14 +1253,16 @@ public class JavacHandlerUtil {
 		}
 		
 		static void setAnnotations(JCTree obj, List<JCAnnotation> anns) {
-			init(obj.getClass());
+			if (ANNOTATIONS == null) return;
 			try {
 				ANNOTATIONS.set(obj, anns);
-			} catch (Exception e) {}
+			} catch (Exception e) {
+				// Ignore
+			}
 		}
 		
 		static JCExpression getUnderlyingType(JCTree obj) {
-			init(obj.getClass());
+			if (UNDERLYING_TYPE == null) return null;
 			try {
 				return (JCExpression) UNDERLYING_TYPE.get(obj);
 			} catch (Exception e) {
@@ -1271,7 +1271,7 @@ public class JavacHandlerUtil {
 		}
 		
 		static JCExpression create(List<JCAnnotation> annotations, JCExpression underlyingType) {
-			initByLoader(underlyingType.getClass().getClassLoader());
+			if (CONSTRUCTOR == null) return underlyingType;
 			try {
 				return (JCExpression) CONSTRUCTOR.newInstance(annotations, underlyingType);
 			} catch (Exception e) {