SnapCode/src/javakit/resolver/ResolverIds.java at master · reportmill/SnapCode · GitHub

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
127
128
129
130
131
132
133
134
package javakit.resolver;
import snap.util.ArrayUtils;
import java.lang.reflect.*;

/**
 * Utility methods to get ids for Resolver objects.
 */
public class ResolverIds {

    /**
     * Returns an Id for a Java.lang.Class.
     */
    public static String getIdForClass(Class<?> aClass)
    {
        if (aClass.isArray())
            return getIdForClass(aClass.getComponentType()) + "[]";
        return aClass.getName();
    }

    /**
     * Returns an Id for Java.lang.reflect.Type.
     */
    public static String getIdForType(Type aType)
    {
        // Handle Class
        if (aType instanceof Class)
            return getIdForClass((Class<?>) aType);

        // Handle GenericArrayType: CompType[]
        if (aType instanceof GenericArrayType)
            return getIdForGenericArrayType((GenericArrayType) aType);

        // Handle ParameterizedType: RawType<TypeArg,...>
        if (aType instanceof ParameterizedType)
            return getIdForParameterizedType((ParameterizedType) aType);

        // Handle TypeVariable: DeclType.Name
        if (aType instanceof TypeVariable)
            return getIdForTypeVariable((TypeVariable<?>) aType);

        // Handle WildcardType: Need to fix for
        WildcardType wc = (WildcardType) aType;
        Type[] bounds = wc.getLowerBounds().length > 0 ? wc.getLowerBounds() : wc.getUpperBounds();
        Type bound = bounds[0];
        String boundStr = getIdForType(bound);
        return boundStr;
    }

    /**
     * Returns an Id for Java.lang.reflect.ParameterizedType.
     */
    public static String getIdForGenericArrayType(GenericArrayType genericArrayType)
    {
        Type compType = genericArrayType.getGenericComponentType();
        String compTypeStr = getIdForType(compType);
        return compTypeStr + "[]";
    }

    /**
     * Returns an Id for Java.lang.reflect.ParameterizedType.
     */
    public static String getIdForParameterizedType(ParameterizedType parameterizedType)
    {
        // Get RawType id
        Type rawType = parameterizedType.getRawType();
        String rawTypeId = getIdForType(rawType);

        // Get typeArgs id (just return rawType id if no args
        Type[] typeArgs = parameterizedType.getActualTypeArguments();
        if (typeArgs.length == 0)
            return rawTypeId;

        // Return RawType<TypeArgs>          // Was map(typeArg -> getIdForType(typeArg))
        String typeArgsNameStr = ArrayUtils.mapToStringsAndJoin(typeArgs, Type::getTypeName, ",");
        return rawTypeId + '<' + typeArgsNameStr + '>';
    }

    /**
     * Returns an id string for given Java part.
     */
    public static String getIdForParameterizedTypeParts(JavaDecl aRawType, JavaType[] theTypes)
    {
        // Get RawType id (just return if no args)
        String rawTypeId = aRawType.getId();
        if (theTypes.length == 0)
            return rawTypeId;

        // Return RawType<TypeArgs>         // Was map(JavaType::getId)
        String typeArgsNameStr = ArrayUtils.mapToStringsAndJoin(theTypes, JavaType::getName, ",");
        return rawTypeId + '<' + typeArgsNameStr + '>';
    }

    /**
     * Returns an Id for Java.lang.reflect.TypeVariable.
     */
    public static String getIdForTypeVariable(TypeVariable<?> typeVariable)
    {
        // Get GenericDecl and TypeVar.Name
        GenericDeclaration genericDecl = typeVariable.getGenericDeclaration();
        String genericDeclId = genericDecl instanceof Member ?
                getIdForMember((Member) genericDecl) :
                getIdForClass((Class<?>) genericDecl);
        String typeVarName = typeVariable.getName();

        // Return GenericDecl.TypeVarName
        return genericDeclId + '.' + typeVarName;
    }

    /**
     * Returns an Id for a Java.lang.reflect.Member.
     */
    public static String getIdForMember(Member aMember)
    {
        // Get id for Member.DeclaringClass
        Class<?> declaringClass = aMember.getDeclaringClass();
        String classId = getIdForClass(declaringClass);

        // Handle Field: DeclClassName.<Name>
        if (aMember instanceof Field)
            return classId + '.' + aMember.getName();

        // Get executable parameter types string: (type1,type2,...)
        Executable executable = (Executable) aMember;
        Class<?>[] paramClasses = executable.getParameterTypes();
        String paramClassesStr = '(' + ArrayUtils.mapToStringsAndJoin(paramClasses, ResolverIds::getIdForClass, ",") + ')';

        // Handle constructor: DeclClassName(paramsTypesString)
        if (aMember instanceof Constructor)
            return classId + paramClassesStr;

        // Handle method: DeclClassName.MethodName(paramTypesString)
        return classId + '.' + aMember.getName() + paramClassesStr;
    }
}