tiennm99/lombok
1
0 Fork 0
mirror of https://github.com/tiennm99/lombok.git synced 2026-10-14 06:17:44 +00:00
Code Issues Packages Projects Releases Wiki Activity

Refactor reflective type annotation handling

Browse Source
This commit is contained in:
Rawi01 committed 2023-04-29 10:59:04 +02:00
1 parent 8aa54b7f25
commit eac764691b
2 files changed
+32 -59
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

src/core/lombok/javac/handlers/HandleEqualsAndHashCode.java
+6 -33
View File
@@ -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();
}
}
src/core/lombok/javac/handlers/JavacHandlerUtil.java
+26 -26
View File
@@ -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) {