FieldTypeSignature:
ClassTypeSignature
ArrayTypeSignature
TypeVariableSignature
@param type
@return
162694
private static void fieldTypeSignature(Result sb, TypeMirror type) throws IOException
    {
        switch (type.getKind())
        {
            case DECLARED:
                classTypeSignature(sb, type);
                break;
            case TYPEVAR:
                typeVariableSignature(sb, (TypeVariable)type);
                break;
            case ARRAY:
                arrayTypeSignature(sb, (ArrayType)type);
                break;
            default:
                //throw new UnsupportedOperationException(type.getKind()+" unsupported");
        }
    }
547684
@SuppressWarnings({ "rawtypes", "unchecked", "deprecation" })
    protected TypeInformation<?> createInfo(Type fieldType) {

        if (fieldType.equals(this.type)) {
            return this;
        }

        if (fieldType instanceof Class) {
            return new ClassTypeInformation((Class<?>) fieldType);
        }

        Class<S> resolveType = resolveClass(fieldType);
        Map<TypeVariable, Type> variableMap = new HashMap<TypeVariable, Type>();
        variableMap.putAll(GenericTypeResolver.getTypeVariableMap(resolveType));

        if (fieldType instanceof ParameterizedType) {

            ParameterizedType parameterizedType = (ParameterizedType) fieldType;

            TypeVariable<Class<S>>[] typeParameters = resolveType.getTypeParameters();
            Type[] arguments = parameterizedType.getActualTypeArguments();

            for (int i = 0; i < typeParameters.length; i++) {
                variableMap.put(typeParameters[i], arguments[i]);
            }

            return new ParametrizedTypeInformation(parameterizedType, this, variableMap);
        }

        if (fieldType instanceof TypeVariable) {
            TypeVariable<?> variable = (TypeVariable<?>) fieldType;
            return new TypeVariableTypeInformation(variable, type, this, variableMap);
        }

        if (fieldType instanceof GenericArrayType) {
            return new GenericArrayTypeInformation((GenericArrayType) fieldType, this, variableMap);
        }

        if (fieldType instanceof WildcardType) {

            WildcardType wildcardType = (WildcardType) fieldType;
            return new WildcardTypeInformation(wildcardType, variableMap);
        }

        throw new IllegalArgumentException();
    }
791445
private TypeSignature getTypeSignature() {
        if (typeSignature == null) {
            try {
                // There can't be any type variables to resolve in either ClassRefTypeSignature or
                // BaseTypeSignature, so just set definingClassName to null
                typeSignature = TypeSignature.parse(typeDescriptorStr, /* definingClassName = */ null);
                typeSignature.setScanResult(scanResult);
            } catch (final ParseException e) {
                throw new IllegalArgumentException(e);
            }
        }
        return typeSignature;
    }
518792
public static String toStringWithNamedGenerics(final Class<?> type) {
        return toStringType(new ParameterizedTypeImpl(type, type.getTypeParameters()), new PrintableGenericsMap());
    }
118549
@SuppressWarnings("serial")
    public static Type[] forTypeParameters(final Class<?> type) {
        Type[] result = new Type[type.getTypeParameters().length];
        for (int i = 0; i < result.length; i++) {
            final int index = i;
            result[i] = forTypeProvider(new DefaultTypeProvider() {
                @Override
                public Type getType() {
                    return type.getTypeParameters()[index];
                }
            });
        }
        return result;
    }
722892
@Nullable
    public static String toArraySignature(String typeName) {
        String sig = classToSignature(typeName);
        if ((sig == null) || (sig.length() == 0)) {
            return sig;
        }
        return Values.SIG_ARRAY_PREFIX + sig;
    }
1338533
public static String createTypeSignature(final String methodName, final Class<?>[] paramTypes) {
        final StringBuffer sb = new StringBuffer();
        sb.append(methodName);
        sb.append("(");
        for (int i = 0; i < paramTypes.length; i++) {
            if (i > 0) {
                sb.append(", ");
            }
            sb.append(paramTypes[i].getSimpleName());
        }
        sb.append(")");
        return sb.toString();
    }
482003
public static boolean isPropertyType(final Type type) {
        if (type instanceof GenericArrayType) {
            return isPropertyType(((GenericArrayType) type).getGenericComponentType());
        }
        if (type instanceof ParameterizedType) {
            return isPropertyType(((ParameterizedType) type).getRawType());
        }
        return type instanceof Class && isPropertyType((Class) type);
    }
384942
public String getTypeNameForCast(Class<?> type) {
        Integer jdbcType = jdbcTypeMapping.get(type);
        if (jdbcType == null) {
            jdbcType = javaTypeMapping.getType(type).getSQLTypes()[0];
        }
        return templates.getCastTypeNameForCode(jdbcType);
    }
1245604
private ClassTypeSignature getClassTypeSignature(
			ParameterizedType parameterizedType) {
		Class<?> rawType = (Class<?>) parameterizedType.getRawType();
		Type[] typeArguments = parameterizedType.getActualTypeArguments();
		TypeArgSignature[] typeArgSignatures = new TypeArgSignature[typeArguments.length];
		for (int i = 0; i < typeArguments.length; i++) {
			typeArgSignatures[i] = getTypeArgSignature(typeArguments[i]);
		}

		String binaryName = rawType.isMemberClass() ? rawType.getSimpleName()
				: rawType.getName();
		ClassTypeSignature ownerTypeSignature = parameterizedType
				.getOwnerType() == null ? null
				: (ClassTypeSignature) getFullTypeSignature(parameterizedType
						.getOwnerType());
		ClassTypeSignature classTypeSignature = new ClassTypeSignature(
				binaryName, typeArgSignatures, ownerTypeSignature);
		return classTypeSignature;
	}
208621
public ArrayClassInfo getArrayClassInfo(String typeClassName, Type arrayType) {
        ClassInfoImpl elementClassInfo = getDelayableClassInfo(arrayType.getElementType());

        return new ArrayClassInfo(typeClassName, elementClassInfo);
    }
1110904
private static String createTypeId(Type type) {
        if (type instanceof Class<?>)
            return Class.class.cast(type).getName();

        if (type instanceof ParameterizedType)
            return createTypeId(((ParameterizedType) type).getRawType())
                + Stream.of(((ParameterizedType) type).getActualTypeArguments())
                .map(CdiSpiHelper::createTypeId)
                .collect(joining(",", "<", ">"));

        if (type instanceof TypeVariable<?>)
            return TypeVariable.class.cast(type).getName();

        if (type instanceof GenericArrayType)
            return createTypeId(GenericArrayType.class.cast(type).getGenericComponentType());

        throw new UnsupportedOperationException("Unable to create type id for type [" + type + "]");
    }
753922
protected void registerAllTypeVariables(Type classType) {
        Queue<Type> typesToRegister = new LinkedList<Type>();
        Set<Type> registeredTypes = new HashSet<Type>();
        typesToRegister.add(classType);

        while (!typesToRegister.isEmpty()) {
            Type typeToRegister = typesToRegister.poll();
            if (typeToRegister == null || registeredTypes.contains(typeToRegister)) {
                continue;
            }

            registerTypeVariablesOn(typeToRegister);
            registeredTypes.add(typeToRegister);

            Class<?> rawType = extractRawTypeOf(typeToRegister);
            typesToRegister.add(rawType.getGenericSuperclass());
            typesToRegister.addAll(Arrays.asList(rawType.getGenericInterfaces()));
        }
    }
384962
public static String getVariableType(String type) throws IOException {
        if (getVariableTypes() != null) {
            String newType = getVariableTypes().get(type);
            if (newType != null)
                return newType;
        }
        return type;
    }
1059929
public static Class<?> getRawType(Type type) {
		if (type instanceof Class) {
			return (Class<?>) type;
		} else if (type instanceof ParameterizedType) {
			ParameterizedType actualType = (ParameterizedType) type;
			return getRawType(actualType.getRawType());
		} else if (type instanceof GenericArrayType) {
			GenericArrayType genericArrayType = (GenericArrayType) type;
			Object rawArrayType = Array.newInstance(getRawType(genericArrayType
					.getGenericComponentType()), 0);
			return rawArrayType.getClass();
		} else if (type instanceof WildcardType) {
			WildcardType castedType = (WildcardType) type;
			return getRawType(castedType.getUpperBounds()[0]);
		} else {
			throw new IllegalArgumentException(
					"Type \'"
							+ type
							+ "\' is not a Class, "
							+ "ParameterizedType, or GenericArrayType. Can't extract class.");
		}
	}
804920
private static char arrayTypeToName(int type) {
        switch (type) {
            case ByteCode.T_BOOLEAN:
                return 'Z';
            case ByteCode.T_CHAR:
                return 'C';
            case ByteCode.T_FLOAT:
                return 'F';
            case ByteCode.T_DOUBLE:
                return 'D';
            case ByteCode.T_BYTE:
                return 'B';
            case ByteCode.T_SHORT:
                return 'S';
            case ByteCode.T_INT:
                return 'I';
            case ByteCode.T_LONG:
                return 'J';
            default:
                throw new IllegalArgumentException("bad operand");
        }
    }
1048646
public static FullTypeSignature getTypeSignature(Class<?> clazz, Class<?>[] typeArgs) {
		ClassTypeSignature rawClassTypeSignature = (ClassTypeSignature) javaTypeToTypeSignature
				.getTypeSignature(clazz);
		TypeArgSignature[] typeArgSignatures = new TypeArgSignature[typeArgs.length];
		for (int i = 0; i < typeArgs.length; i++) {
			typeArgSignatures[i] = new TypeArgSignature(
					TypeArgSignature.NO_WILDCARD,
					(FieldTypeSignature) javaTypeToTypeSignature
							.getTypeSignature(typeArgs[i]));
		}
		ClassTypeSignature classTypeSignature = new ClassTypeSignature(
				rawClassTypeSignature.getBinaryName(), typeArgSignatures,
				rawClassTypeSignature.getOwnerTypeSignature());

		return classTypeSignature;
	}