/** Uses both {@link Types#erasure} and string manipulation to strip any generic types. */ private String doubleErasure(TypeMirror elementType) { String name = typeUtils.erasure(elementType).toString(); int typeParamStart = name.indexOf('<'); if (typeParamStart != -1) { name = name.substring(0, typeParamStart); } return name; }
private boolean isRequestBuilder(TypeMirror typeMirror) { TypeMirror toCompare = processingEnvironment.getTypeUtils().erasure(typeMirror); return toCompare.toString().equals("com.bumptech.glide.RequestBuilder"); }
TypeMirror findInterface(TypeElement shadowPickerType, Class<?> interfaceClass) { TypeMirror shadowPickerMirror = elements .getTypeElement(interfaceClass.getName()) .asType(); for (TypeMirror typeMirror : shadowPickerType.getInterfaces()) { if (types.erasure(typeMirror).equals(types.erasure(shadowPickerMirror))) { return typeMirror; } } return null; }
/** * Generates overrides of all methods in {@code com.bumptech.glide.RequestBuilder} that return * {@code com.bumptech.glide.RequestBuilder} so that they return our generated subclass instead. */ private List<MethodSpec> generateRequestBuilderOverrides() { TypeMirror rawRequestBuilderType = processingEnv.getTypeUtils().erasure(requestBuilderType.asType()); return Lists.transform( processorUtil.findInstanceMethodsReturning(requestBuilderType, rawRequestBuilderType), new Function<ExecutableElement, MethodSpec>() { @Override public MethodSpec apply(ExecutableElement input) { return generateRequestBuilderOverride(input); } }); }
Accessors(ProcessingEnvironment environment) { super(environment); this.iterableElement = elements.getTypeElement(Iterable.class.getName()); this.iterableTypeErasure = types.erasure(iterableElement.asType()); this.invokableType = elements.getTypeElement(Templates.Invokable.class.getCanonicalName()).asType(); this.iterationType = elements.getTypeElement(Templates.Iteration.class.getCanonicalName()).asType(); this.objectType = elements.getTypeElement(Object.class.getCanonicalName()).asType(); }
private TypeMirror getErasedType(Class<?> clazz) { return env.getTypeUtils().erasure(env.getElementUtils().getTypeElement(clazz.getName()).asType()); }
static boolean isSubtype(TypeMirror e1, TypeMirror e2, Types types) { return types.isSubtype(e1, types.erasure(e2)); }
private Map<String, TypeMirror> getActualTypes(Types typeUtils, DeclaredType baseClass, TypeMirror annotatedClass) { List<TypeMirror> superTypes = new ArrayList<>(); superTypes.add(annotatedClass); while (!superTypes.isEmpty()) { TypeMirror x = superTypes.remove(0); if (typeUtils.isSameType(typeUtils.erasure(x), typeUtils.erasure(baseClass))) { DeclaredType type = (DeclaredType) x; Map<String, TypeMirror> actualTypes = new HashMap<>(); for (int i = 0; i < type.getTypeArguments().size(); i++) { TypeMirror actualArg = type.getTypeArguments().get(i); TypeMirror formalArg = baseClass.getTypeArguments().get(i); if (!typeUtils.isSameType(actualArg, formalArg)) { actualTypes.put(formalArg.toString(), actualArg); } } return actualTypes; } superTypes.addAll(typeUtils.directSupertypes(x)); } return Collections.emptyMap(); }
private boolean isAssignable(TypeMirror type, TypeMirror iface) { return env.getTypeUtils().isAssignable(type, iface) // XXX Eclipse 3.6 support || env.getTypeUtils().erasure(type).toString().equals(iface.toString()); }
private boolean isIterableType(TypeMirror type) { return types.isSubtype(types.erasure(type), iterableTypeErasure); }
private Stream<CompilationMessage> validateReturnType( ExecutableElement method ) { String streamClassName = Stream.class.getCanonicalName(); TypeMirror streamType = typeUtils.erasure( elementUtils.getTypeElement( streamClassName ).asType() ); TypeMirror returnType = method.getReturnType(); TypeMirror erasedReturnType = typeUtils.erasure( returnType ); TypeMirror voidType = typeUtils.getNoType( TypeKind.VOID ); if ( typeUtils.isSameType( returnType, voidType ) ) { return Stream.empty(); } if ( !typeUtils.isSubtype( erasedReturnType, streamType ) ) { return Stream.of( new ReturnTypeError( method, "Return type of %s#%s must be %s", method.getEnclosingElement().getSimpleName(), method.getSimpleName(), streamClassName ) ); } return recordVisitor.visit( returnType ); }
private boolean isValidErasedType( TypeMirror actualType ) { return whitelistedTypes.stream().anyMatch( type -> { TypeMirror erasedAllowedType = typeUtils.erasure( type ); TypeMirror map = typeUtils.erasure( typeMirrors.typeMirror( Map.class ) ); TypeMirror list = typeUtils.erasure( typeMirrors.typeMirror( List.class ) ); if ( typeUtils.isSameType( erasedAllowedType, map ) || typeUtils.isSameType( erasedAllowedType, list ) ) { return typeUtils.isSubtype( actualType, erasedAllowedType ); } return typeUtils.isSameType( actualType, erasedAllowedType ); } ); }
@Override public AnnotationMetaAttribute visitTypeVariable(TypeVariable t, Element element) { // METAGEN-29 - for a type variable we use the upper bound TypeMirror mirror = t.getUpperBound(); TypeMirror erasedType = context.getTypeUtils().erasure( mirror ); return new AnnotationMetaSingleAttribute( entity, element, erasedType.toString() ); }
public static String extractClosestRealTypeAsString(TypeMirror type, Context context) { if ( type instanceof TypeVariable ) { final TypeMirror compositeUpperBound = ( (TypeVariable) type ).getUpperBound(); return extractClosestRealTypeAsString( compositeUpperBound, context ); } else { final TypeMirror erasureType = context.getTypeUtils().erasure( type ); if ( TypeKind.ARRAY.equals( erasureType.getKind() ) ) { // keep old behavior here for arrays since #asElement returns null for them. return erasureType.toString(); } else { return ( (TypeElement) context.getTypeUtils().asElement( erasureType ) ).getQualifiedName().toString(); } } }
/** Generates the list of overrides of methods that return {@code RequestBuilder}. */ private List<MethodSpec> generateRequestManagerRequestBuilderMethodOverrides() { // Without the erasure, this is a RequestBuilder<Y>. A RequestBuilder<X> is not assignable to a // RequestBuilder<Y>. After type erasure this is a RequestBuilder. A RequestBuilder<X> is // assignable to the raw RequestBuilder. TypeMirror rawRequestBuilder = processingEnv.getTypeUtils() .erasure(requestBuilderType.asType()); return FluentIterable.from( processorUtil.findInstanceMethodsReturning(requestManagerType, rawRequestBuilder)) .filter(new Predicate<ExecutableElement>() { @Override public boolean apply(ExecutableElement input) { // Skip the <T> as(Class<T>) method. return !input.getSimpleName().toString().equals("as"); } }) .transform(new Function<ExecutableElement, MethodSpec>() { @Override public MethodSpec apply(ExecutableElement input) { return generateRequestManagerRequestBuilderMethodOverride(input); } }) .toList(); }
@Override public void assignValue(JBlock targetBlock, IJAssignmentTarget fieldRef, EComponentHolder holder, Element element, Element param) { TypeMirror fieldTypeMirror = param.asType(); TypeMirror erasedFieldTypeMirror = getProcessingEnvironment().getTypeUtils().erasure(fieldTypeMirror); String interfaceName = erasedFieldTypeMirror.toString(); String generatedClassName = interfaceName + classSuffix(); AbstractJClass clazz = codeModelHelper.narrowGeneratedClass(getJClass(generatedClassName), fieldTypeMirror); targetBlock.add(fieldRef.assign(JExpr._new(clazz).arg(holder.getContextRef()))); }
@Override public boolean test( TypeMirror typeMirror ) { TypeMirror erasedActualType = typeUtils.erasure( typeMirror ); return isValidErasedType( erasedActualType ) && (!isSameErasedType( List.class, typeMirror ) || isValidListType( typeMirror )) && (!isSameErasedType( Map.class, typeMirror ) || isValidMapType( typeMirror )); }
@Override public void assignValue(JBlock targetBlock, IJAssignmentTarget fieldRef, EComponentHolder holder, Element element, Element param) { TypeMirror typeMirror = annotationHelper.extractAnnotationClassParameter(element); if (typeMirror == null) { typeMirror = param.asType(); typeMirror = getProcessingEnvironment().getTypeUtils().erasure(typeMirror); } String typeQualifiedName = typeMirror.toString(); AbstractJClass injectedClass = getJClass(annotationHelper.generatedClassQualifiedNameFromQualifiedName(typeQualifiedName)); JInvocation beanInstance = injectedClass.staticInvoke(EBeanHolder.GET_INSTANCE_METHOD_NAME).arg(holder.getContextRef()); IJStatement assignment = fieldRef.assign(beanInstance); if (param.getKind() == ElementKind.FIELD) { boolean hasNonConfigurationInstanceAnnotation = element.getAnnotation(NonConfigurationInstance.class) != null; if (hasNonConfigurationInstanceAnnotation) { JConditional conditional = targetBlock._if(fieldRef.eq(_null())); conditional._then().add(assignment); assignment = conditional; } } targetBlock.add(assignment); }