Examples with Types javax.lang.model.util.Types used on opensource projects

Example 21 with Types

use of javax.lang.model.util.Types in project androidannotations by androidannotations.

the class APTCodeModelHelper method getActualType.

// TODO it would be nice to cache the result map for better performance
public TypeMirror getActualType(Element element, DeclaredType enclosingClassType, GeneratedClassHolder holder) {
    Types types = environment.getProcessingEnvironment().getTypeUtils();
    TypeMirror annotatedClass = holder.getAnnotatedElement().asType();
    Map<String, TypeMirror> actualTypes = getActualTypes(types, enclosingClassType, annotatedClass);
    TypeMirror type = actualTypes.get(element.asType().toString());
    return type == null ? element.asType() : type;
}

Example 22 with Types

use of javax.lang.model.util.Types in project androidannotations by androidannotations.

the class OrmLiteValidatorHelper method extendsOrmLiteDao.

public void extendsOrmLiteDao(Element element, ElementValidation valid, OrmLiteHelper ormLiteHelper) {
    if (!valid.isValid()) {
        // could be missing ormlite classes
        return;
    }
    TypeMirror elementTypeMirror = element.asType();
    Types typeUtils = annotationHelper.getTypeUtils();
    DeclaredType daoParametrizedType = ormLiteHelper.getDaoParametrizedType();
    DeclaredType runtimeExceptionDaoParametrizedType = ormLiteHelper.getRuntimeExceptionDaoParametrizedType();
    // RuntimeExceptionDao<?, ?>
    if (!annotationHelper.isSubtype(elementTypeMirror, daoParametrizedType) && !annotationHelper.isSubtype(elementTypeMirror, runtimeExceptionDaoParametrizedType)) {
        valid.addError(//
        "%s can only be used on an element that extends " + daoParametrizedType.toString() + " or " + runtimeExceptionDaoParametrizedType.toString());
        return;
    }
    if (//
    annotationHelper.isSubtype(elementTypeMirror, runtimeExceptionDaoParametrizedType) && !typeUtils.isAssignable(ormLiteHelper.getTypedRuntimeExceptionDao(element), elementTypeMirror)) {
        boolean hasConstructor = false;
        Element elementType = typeUtils.asElement(elementTypeMirror);
        DeclaredType daoWithTypedParameters = ormLiteHelper.getTypedDao(element);
        for (ExecutableElement constructor : ElementFilter.constructorsIn(elementType.getEnclosedElements())) {
            List<? extends VariableElement> parameters = constructor.getParameters();
            if (parameters.size() == 1) {
                TypeMirror type = parameters.get(0).asType();
                if (annotationHelper.isSubtype(type, daoWithTypedParameters)) {
                    hasConstructor = true;
                }
            }
        }
        if (!hasConstructor) {
            valid.addError(elementTypeMirror.toString() + " requires a constructor that takes only a " + daoWithTypedParameters.toString());
        }
    }
}

Example 23 with Types

use of javax.lang.model.util.Types in project RoboBinding by RoboBinding.

the class TypeMirrorWrapperTest method supportedTypeMirrors.

@DataPoints("supportedTypeMirrors")
public static TypeMirrorToWrapped[] supportedTypeMirrors() {
    Types types = compilation.getTypes();
    NoType voidType = types.getNoType(TypeKind.VOID);
    PrimitiveType primitiveType = types.getPrimitiveType(TypeKind.INT);
    Elements elements = compilation.getElements();
    DeclaredType declaredType = (DeclaredType) elements.getTypeElement(Object.class.getName()).asType();
    ArrayType arrayType = types.getArrayType(declaredType);
    return new TypeMirrorToWrapped[] { a(voidType).itsWrapped(WrappedVoidType.class), a(primitiveType).itsWrapped(WrappedPrimitiveType.class), a(declaredType).itsWrapped(WrappedDeclaredType.class), a(arrayType).itsWrapped(WrappedArrayType.class) };
}

Example 24 with Types

use of javax.lang.model.util.Types in project requery by requery.

the class EntityGraphValidator method validateEntity.

private Set<ElementValidator> validateEntity(EntityDescriptor entity) {
    Set<ElementValidator> results = new LinkedHashSet<>();
    for (Map.Entry<Element, ? extends AttributeDescriptor> entry : entity.attributes().entrySet()) {
        AttributeDescriptor attribute = entry.getValue();
        ElementValidator validator = new ElementValidator(attribute.element(), processingEnvironment);
        // check mapped associations
        if (attribute.cardinality() != null) {
            Optional<EntityDescriptor> referencingEntity = graph.referencingEntity(attribute);
            if (referencingEntity.isPresent()) {
                EntityDescriptor referenced = referencingEntity.get();
                Set<AttributeDescriptor> mappings = graph.mappedAttributes(entity, attribute, referenced);
                if (mappings.isEmpty()) {
                    if (attribute.cardinality() == Cardinality.ONE_TO_ONE && !attribute.isForeignKey()) {
                        validator.error("Single sided @OneToOne should specify @ForeignKey/@JoinColumn");
                    } else if (attribute.cardinality() == Cardinality.ONE_TO_MANY) {
                        validator.error("Corresponding @OneToMany relation not present in mapped entity");
                    }
                } else if (mappings.size() == 1) {
                    // validate the relationship
                    AttributeDescriptor mapped = mappings.iterator().next();
                    validateRelationship(validator, attribute, mapped);
                } else if (mappings.size() > 1) {
                    validator.warning(mappings.size() + " mappings found for: " + attribute + " -> " + referenced.typeName());
                }
            } else {
                validator.warning("Couldn't find referenced element for " + attribute);
            }
        } else {
            Types types = processingEnvironment.getTypeUtils();
            for (EntityDescriptor descriptor : graph.entities()) {
                if (types.isSubtype(descriptor.element().asType(), attribute.typeMirror()) && attribute.converterName() == null) {
                    validator.error("Entity reference missing relationship annotation");
                }
            }
        }
        // checked foreign key reference
        if (attribute.isForeignKey()) {
            Optional<EntityDescriptor> referenced = graph.referencingEntity(attribute);
            if (referenced.isPresent()) {
                Optional<? extends AttributeDescriptor> referencedElement = graph.referencingAttribute(attribute, referenced.get());
                if (!referencedElement.isPresent()) {
                    validator.warning("Couldn't find referenced element " + referenced.get().typeName() + " for " + attribute);
                } else {
                    // check all the foreign keys and see if they reference this entity
                    referenced.get().attributes().values().stream().filter(AttributeDescriptor::isForeignKey).map(graph::referencingEntity).filter(Optional::isPresent).map(Optional::get).filter(entity::equals).findAny().ifPresent(other -> validator.warning("Circular Foreign Key reference found between " + entity.typeName() + " and " + other.typeName(), ForeignKey.class));
                }
            } else if (attribute.cardinality() != null) {
                validator.error("Couldn't find referenced attribute " + attribute.referencedColumn() + " for " + attribute);
            }
        }
        if (validator.hasErrors() || validator.hasWarnings()) {
            results.add(validator);
        }
    }
    return results;
}

Example 25 with Types

use of javax.lang.model.util.Types in project requery by requery.

the class AttributeMember method checkMemberType.

private void checkMemberType(ProcessingEnvironment processingEnvironment, TypeMirror type, Set<ElementValidator> validators) {
    builderClass = AttributeBuilder.class;
    Types types = processingEnvironment.getTypeUtils();
    isBoolean = type.getKind() == TypeKind.BOOLEAN;
    if (type.getKind() == TypeKind.DECLARED) {
        TypeElement element = (TypeElement) types.asElement(type);
        if (element != null) {
            // only set if the attribute is relational
            if (cardinality != null) {
                isIterable = Mirrors.isInstance(types, element, Iterable.class);
            }
            isMap = Mirrors.isInstance(types, element, Map.class);
            if (isMap && cardinality != null) {
                builderClass = MapAttributeBuilder.class;
            }
            isOptional = Mirrors.isInstance(types, element, Optional.class);
            isBoolean = Mirrors.isInstance(types, element, Boolean.class);
        }
    }
    if (isIterable) {
        ElementValidator validator = validateCollectionType(processingEnvironment);
        if (validator != null) {
            validators.add(validator);
        }
    }
}