/** * Tests whether one type is a subtype of another. Any type is considered to be * a subtype of itself. */ public boolean isSubtype(TypeMirror potentialSubtype, TypeMirror potentialSupertype) { return getTypeUtils().isSubtype(potentialSubtype, potentialSupertype); }
public boolean isSubType(Element element, TypeMirror typeMirror) { return element != null && types.isSubtype(element.asType(), typeMirror); }
static boolean isSubtype(TypeMirror e1, TypeMirror e2, Types types) { return types.isSubtype(e1, types.erasure(e2)); }
/** * Checks if the given element is in a valid Fragment class */ private boolean isFragmentClass(Element classElement) { List<TypeElement> fragmentTypeElements = Arrays.asList(TYPE_FRAGMENT, TYPE_SUPPORT_FRAGMENT, TYPE_ANDROIDX_FRAGMENT); for (TypeElement fragmentTypeElement : fragmentTypeElements) { if(fragmentTypeElement != null && typeUtils.isSubtype(classElement.asType(), fragmentTypeElement.asType())) { return true; } } return false; }
private boolean isSubtype(Element typeElement, String type) { return processingEnv.getTypeUtils().isSubtype(typeElement.asType(), processingEnv.getElementUtils().getTypeElement(type).asType()); }
private boolean isSubtype(TypeMirror typeMirror, String type) { return processingEnv.getTypeUtils().isSubtype(typeMirror, processingEnv.getElementUtils().getTypeElement(type).asType()); }
private boolean isSubtype(Element typeElement, String type) { return processingEnv.getTypeUtils().isSubtype(typeElement.asType(), processingEnv.getElementUtils().getTypeElement(type).asType()); }
private boolean isSubType(TypeMirror type1, TypeMirror clazz) { return env.getTypeUtils().isSubtype(type1, clazz) // XXX Eclipse 3.6 support || env.getTypeUtils().directSupertypes(type1).contains(clazz); }
private boolean isIterableType(TypeMirror type) { return types.isSubtype(types.erasure(type), iterableTypeErasure); }
public boolean isSubType(TypeMirror type, String className) { return type != null && types.isSubtype(type, typeMirror(className)); }
void processElement(Element e) { if (e instanceof TypeElement) { final TypeMirror t1 = e.asType(); TypeElement typeElement = (TypeElement) e; int idFromStrategy = getIdFromStrategy(typeElement); if (idFromStrategy != 0 || typeUtils.isSubtype(t1, actorTypeMirror) || typeUtils.isSubtype(t1, actorObserverTypeMirror)) { writeClassInfo(typeElement, idFromStrategy); } } e.getEnclosedElements().forEach(this::processElement); }
public PreferencesDelegate(EComponentWithViewSupportHolder holder) { super(holder); Elements elementUtils = holder.getEnvironment().getProcessingEnvironment().getElementUtils(); Types typeUtils = holder.getEnvironment().getProcessingEnvironment().getTypeUtils(); TypeElement supportV7PreferenceFragmentCompat = elementUtils.getTypeElement(CanonicalNameConstants.SUPPORT_V7_PREFERENCE_FRAGMENTCOMPAT); TypeElement andoridxPreferenceFragmentCompat = elementUtils.getTypeElement(CanonicalNameConstants.ANDROIDX_PREFERENCE_FRAGMENTCOMPAT); TypeElement supportV14PreferenceFragment = elementUtils.getTypeElement(CanonicalNameConstants.SUPPORT_V14_PREFERENCE_FRAGMENT); TypeElement andoridxPreferenceFragment = elementUtils.getTypeElement(CanonicalNameConstants.ANDROIDX_PREFERENCE_FRAGMENT); TypeMirror annotatedType = holder.getAnnotatedElement().asType(); if (andoridxPreferenceFragmentCompat != null && typeUtils.isSubtype(annotatedType, andoridxPreferenceFragmentCompat.asType()) || andoridxPreferenceFragment != null && typeUtils.isSubtype(annotatedType, andoridxPreferenceFragment.asType())) { usingAndroidxPreference = true; basePreferenceClass = getClasses().ANDROIDX_PREFERENCE; } else if (supportV7PreferenceFragmentCompat != null && typeUtils.isSubtype(annotatedType, supportV7PreferenceFragmentCompat.asType()) || supportV14PreferenceFragment != null && typeUtils.isSubtype(annotatedType, supportV14PreferenceFragment.asType())) { usingSupportV7Preference = true; basePreferenceClass = getClasses().SUPPORT_V7_PREFERENCE; } else { basePreferenceClass = getClasses().PREFERENCE; } }
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 ); }
/** * Get information about methods returning class type of the original class so we can duplicate * them in the generated class for chaining purposes */ protected void collectMethodsReturningClassType(TypeElement modelClass, Types typeUtils) { TypeElement clazz = modelClass; while (clazz.getSuperclass().getKind() != TypeKind.NONE) { for (Element subElement : clazz.getEnclosedElements()) { Set<Modifier> modifiers = subElement.getModifiers(); if (subElement.getKind() == ElementKind.METHOD && !modifiers.contains(Modifier.PRIVATE) && !modifiers.contains(Modifier.FINAL) && !modifiers.contains(Modifier.STATIC)) { TypeMirror methodReturnType = ((ExecutableType) subElement.asType()).getReturnType(); if (methodReturnType.equals(clazz.asType()) || typeUtils.isSubtype(clazz.asType(), methodReturnType)) { ExecutableElement castedSubElement = ((ExecutableElement) subElement); List<? extends VariableElement> params = castedSubElement.getParameters(); String methodName = subElement.getSimpleName().toString(); if (methodName.equals(RESET_METHOD) && params.isEmpty()) { continue; } methodsReturningClassType.add(new MethodInfo(methodName, modifiers, buildParamSpecs(params), castedSubElement.isVarArgs())); } } } clazz = (TypeElement) typeUtils.asElement(clazz.getSuperclass()); } }
public JInvocation getSuperPutExtraInvocation(TypeMirror elementType, JVar extraParam, JFieldVar extraKeyField) { IJExpression extraParameterArg = extraParam; // Cast to Parcelable, wrap with Parcels.wrap or cast Serializable if needed if (elementType.getKind() == TypeKind.DECLARED) { Elements elementUtils = environment.getProcessingEnvironment().getElementUtils(); TypeMirror parcelableType = elementUtils.getTypeElement(PARCELABLE).asType(); if (typeUtils.isSubtype(elementType, parcelableType)) { TypeMirror serializableType = elementUtils.getTypeElement(SERIALIZABLE).asType(); if (typeUtils.isSubtype(elementType, serializableType)) { extraParameterArg = cast(environment.getClasses().PARCELABLE, extraParameterArg); } } else if (!BundleHelper.METHOD_SUFFIX_BY_TYPE_NAME.containsKey(elementType.toString()) && parcelerHelper.isParcelType(elementType)) { extraParameterArg = environment.getJClass(CanonicalNameConstants.PARCELS_UTILITY_CLASS).staticInvoke("wrap").arg(extraParameterArg); } else { TypeMirror stringType = elementUtils.getTypeElement(STRING).asType(); if (!typeUtils.isSubtype(elementType, stringType)) { extraParameterArg = cast(environment.getClasses().SERIALIZABLE, extraParameterArg); } } } return _super().invoke("extra").arg(extraKeyField).arg(extraParameterArg); }
@Override public final boolean isSubtypeOf(final Class<?> type) { return types.isSubtype(types.erasure(this.typeMirror), toType(type)); }
AptReturnType(final ProcessingEnvironment processingEnv, final TypeMirror returnType, final MessageMethod method) { super(processingEnv, returnType); this.returnType = returnType; this.method = method; delegate = types.asElement(returnType); throwableType = null; if (types.isSubtype(types.erasure(returnType), types.erasure(ElementHelper.toType(elements, Supplier.class)))) { final List<? extends TypeMirror> typeArgs = ElementHelper.getTypeArguments(returnType); if (typeArgs.isEmpty()) { resolvedType = elements.getTypeElement(Object.class.getCanonicalName()).asType(); } else { resolvedType = typeArgs.get(0); } } else { resolvedType = returnType; } isThrowable = types.isSubtype(types.erasure(resolvedType), ElementHelper.toType(elements, Throwable.class)); }
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 Boolean visitMemberSelect(MemberSelectTree node, Void v) { if (node.getIdentifier().contentEquals("class")) { TypeMirror tm = getType(node.getExpression()); if (!verifier.getTypeUtils().isSubtype(tm, btraceServiceTm)) { reportError("no.class.literals", node); } } return super.visitMemberSelect(node, v); }