@Override protected boolean doEquivalent(TypeMirror a, TypeMirror b) { return types.isSameType(a, b); }
public static AnnotationMirror getAnnotationMirror(Types types, Element element, TypeElement annotation) { TypeMirror expectedType = annotation.asType(); for (AnnotationMirror m : element.getAnnotationMirrors()) { if (types.isSameType(expectedType, m.getAnnotationType())) { return m; } } return null; }
private AnnotationMirror getAnnotationMirror(Element element, TypeMirror annotationType) { for (AnnotationMirror mirror : element.getAnnotationMirrors()) { if (processingEnv.getTypeUtils().isSameType(mirror.getAnnotationType(), annotationType)) { return mirror; } } return null; }
public Helpers(ProcessingEnvironment environment) { this.elements = environment.getElementUtils(); this.types = environment.getTypeUtils(); TypeMirror objectMirror = elements.getTypeElement(Object.class.getCanonicalName()).asType(); notObject = t -> !types.isSameType(t, objectMirror); }
private boolean matches( TypeMirror fieldType, Set<String> typeNames ) { return typeMirrors( typeNames ).anyMatch( t -> types.isSameType( t, fieldType ) ); }
static boolean isType(Elements elements, Types types, TypeMirror typeMirror, Class<?> clazz) { TypeMirror classType = KotlinUtilsKt.getTypeMirror(clazz, elements); return types.isSameType(typeMirror, classType); }
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(); }
@Override public Boolean visitDeclared( DeclaredType map, Void ignored ) { List<? extends TypeMirror> typeArguments = map.getTypeArguments(); if ( typeArguments.size() != 2 ) { return Boolean.FALSE; } TypeMirror key = typeArguments.get( 0 ); return typeUtils.isSameType( key, typeMirrors.typeMirror( String.class ) ) && test( typeArguments.get( 1 ) ); } }.visit( typeMirror );
public static ImmutableList<TypeMirror> getTypesFromMirrors( Types types, TypeMirror annotationType, String annotationAttributeName, List<? extends AnnotationMirror> annotationMirrors) { ImmutableList.Builder<TypeMirror> builder = ImmutableList.builder(); for (AnnotationMirror annotationMirror : annotationMirrors) { if (types.isSameType(annotationMirror.getAnnotationType(), annotationType)) { collectTypesFromAnnotationAttribute(annotationAttributeName, builder, annotationMirror); } } return builder.build(); }
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 ); } ); }
private boolean containsTypeMirror(Collection<TypeElement> typeElements, TypeMirror query) { // Ensure we are checking against a type-erased version for normalization purposes. query = typeUtils.erasure(query); for (TypeElement element : typeElements) { final TypeMirror typeMirror = typeUtils.erasure(element.asType()); if (typeUtils.isSameType(typeMirror, query)) { return true; } } return false; } }
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 isSameErasedType( Class<?> type, TypeMirror typeMirror ) { return typeUtils .isSameType( typeUtils.erasure( typeMirrors.typeMirror( type ) ), typeUtils.erasure( typeMirror ) ); }
final TypeMirror type = args.get(i); final VariableElement parameter = parameters.get(i); if (types.isSameType(type, parameter.asType())) { match = true; } else {
@Override public final boolean isSameAs(final Class<?> type) { return types.isSameType(types.erasure(this.typeMirror), toType(type)); }
/** * Returns true if there's a public way to build the value type with an instance no-arg method. * * @param attribute value attribute to check. * @param possibleBuildMethod method which matches {@link StyleMirror#attributeBuilder()} * @return true if this is the possibleBuildMethod can build the value type. */ private static boolean isPossibleBuildMethod(ValueAttribute attribute, Element possibleBuildMethod) { if (possibleBuildMethod.getKind() != ElementKind.METHOD) { return false; } if (!attribute.containingType.names().possibleAttributeBuilder(possibleBuildMethod.getSimpleName())) { return false; } Types typeUtils = attribute.containingType.constitution.protoclass() .environment() .processing() .getTypeUtils(); ExecutableElement candidateBuildMethod = (ExecutableElement) possibleBuildMethod; return !candidateBuildMethod.getModifiers().contains(Modifier.STATIC) && candidateBuildMethod.getModifiers().contains(Modifier.PUBLIC) && candidateBuildMethod.getTypeParameters().isEmpty() && candidateBuildMethod.getReturnType().getKind() == TypeKind.DECLARED && typeUtils.isSameType(candidateBuildMethod.getReturnType(), attribute.containedTypeElement.asType()); }
final TypeMirror superType = element.getSuperclass(); if (!typeUtils.isSameType( superType, elementUtils.getTypeElement("java.lang.Object").asType())) {
if (invalidTypeElement != null && types.isSameType(returnType, types.erasure(invalidTypeElement.asType()))) { error(String.format("@Provides method must not return %s directly: %s.%s", if (!types.isSameType(moduleType.getSuperclass(), objectType)) { error("Modules must not extend from other classes: " + elementToString(module), module);
&& typeUtils.isSameType( candidateCopyMethod.getParameters().get(0).asType(), valueAttribute.containedTypeElement.asType())) {
final Properties expressionProperties, final boolean addGeneratedAnnotation) { final Types types = processingEnv.getTypeUtils(); if (types.isSameType(interfaceElement.asType(), ElementHelper.toType(processingEnv.getElementUtils(), BasicLogger.class))) { MessageInterface result = LOGGER_INTERFACE; if (result == null) {