blob: 38e50e25cb2aebc435ec5666eae039f52a15330a (
plain) (
blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
|
package ftbsc.lll.processor;
import com.squareup.javapoet.ArrayTypeName;
import com.squareup.javapoet.ClassName;
import com.squareup.javapoet.MethodSpec;
import com.squareup.javapoet.TypeName;
import ftbsc.lll.tools.DescriptorBuilder;
import javax.lang.model.element.ExecutableElement;
import javax.lang.model.element.Modifier;
import javax.lang.model.element.TypeElement;
import javax.lang.model.type.TypeMirror;
import java.lang.annotation.Annotation;
import java.util.List;
import java.util.stream.Collectors;
/**
* Collection of static utils that didn't really fit into the main class.
*/
public class ASTUtils {
/**
* Finds, among the methods of a class cl, the one annotated with ann, and tries to build
* a {@link ExecutableElement} from it.
* @param cl the {@link ExecutableElement} for the class containing the desired method
* @param ann the {@link Class} corresponding to the desired annotation
* @return a {@link List} of {@link MethodSpec}s annotated with the given annotation
* @since 0.2.0
*/
public static List<ExecutableElement> findAnnotatedMethods(TypeElement cl, Class<? extends Annotation> ann) {
return cl.getEnclosedElements()
.stream()
.filter(e -> e.getAnnotation(ann) != null)
.map(e -> (ExecutableElement) e)
.collect(Collectors.toList());
}
/**
* Builds a type descriptor from the given {@link TypeMirror}
* @param t the {@link TypeMirror} representing the desired type
* @return a {@link String} containing the relevant descriptor
*/
public static String descriptorFromType(TypeMirror t) {
TypeName type = TypeName.get(t);
StringBuilder desc = new StringBuilder();
//add array brackets
while(type instanceof ArrayTypeName) {
desc.append("[");
type = ((ArrayTypeName) type).componentType;
}
if(type instanceof ClassName) {
ClassName var = (ClassName) type;
desc.append(DescriptorBuilder.nameToDescriptor(var.canonicalName(), 0));
} else {
if(TypeName.BOOLEAN.equals(type))
desc.append("Z");
else if(TypeName.CHAR.equals(type))
desc.append("C");
else if(TypeName.BYTE.equals(type))
desc.append("B");
else if(TypeName.SHORT.equals(type))
desc.append("S");
else if(TypeName.INT.equals(type))
desc.append("I");
else if(TypeName.FLOAT.equals(type))
desc.append("F");
else if(TypeName.LONG.equals(type))
desc.append("J");
else if(TypeName.DOUBLE.equals(type))
desc.append("D");
else if(TypeName.VOID.equals(type))
desc.append("V");
}
return desc.toString();
}
/**
* Builds a method descriptor from the given {@link ExecutableElement}.
* @param m the {@link ExecutableElement} for the method
* @return a {@link String} containing the relevant descriptor
*/
public static String descriptorFromMethodSpec(ExecutableElement m) {
StringBuilder methodSignature = new StringBuilder();
methodSignature.append("(");
m.getParameters().forEach(p -> methodSignature.append(descriptorFromType(p.asType())));
methodSignature.append(")");
methodSignature.append(descriptorFromType(m.getReturnType()));
return methodSignature.toString();
}
/**
* Maps a {@link javax.lang.model.element.Modifier} to its reflective
* {@link java.lang.reflect.Modifier} equivalent.
* @param m the {@link Modifier} to map
* @return an integer representing the modifier
* @see java.lang.reflect.Modifier
* @since 0.2.0
*/
public static int mapModifier(Modifier m) {
switch(m) {
case PUBLIC:
return java.lang.reflect.Modifier.PUBLIC;
case PROTECTED:
return java.lang.reflect.Modifier.PROTECTED;
case PRIVATE:
return java.lang.reflect.Modifier.PRIVATE;
case ABSTRACT:
return java.lang.reflect.Modifier.ABSTRACT;
case STATIC:
return java.lang.reflect.Modifier.STATIC;
case FINAL:
return java.lang.reflect.Modifier.FINAL;
case TRANSIENT:
return java.lang.reflect.Modifier.TRANSIENT;
case VOLATILE:
return java.lang.reflect.Modifier.VOLATILE;
case SYNCHRONIZED:
return java.lang.reflect.Modifier.SYNCHRONIZED;
case NATIVE:
return java.lang.reflect.Modifier.NATIVE;
case STRICTFP:
return java.lang.reflect.Modifier.STRICT;
default:
return 0;
}
}
}
|
zaaarf