public boolean needToCastBundleType(TypeMirror type) throws InvalidTypeException { if (isPrimitive(type)) { return false; } if (isArrayType(type)) { return needToCastArrayType((ArrayType) type); } if (isArrayListType(type)) { return false; } if (isSparseParcelableArray(type)) { return needToCastSparseParcelableArray((DeclaredType) type); } if (types.isAssignable(type, bundleType)) { return !types.isSameType(type, bundleType); } if (isAggregateType(type)) { return needToCastAggregateType(type); } if (types.isAssignable(type, serializableType)) { return !types.isSameType(type, serializableType); } throw new InvalidTypeException(InvalidTypeException.Container.BUNDLE, type); }
public boolean needToCastIntentType(TypeMirror type) throws InvalidTypeException { if (isPrimitive(type)) { return false; } if (isArrayType(type)) { return needToCastArrayType((ArrayType) type); } if (isArrayListType(type)) { return false; } if (types.isAssignable(type, bundleType)) { return !types.isSameType(type, bundleType); } if (isAggregateType(type)) { return needToCastAggregateType(type); } if (types.isAssignable(type, serializableType)) { return !types.isSameType(type, serializableType); } throw new InvalidTypeException(InvalidTypeException.Container.INTENT, type); }
public String getBundleType(TypeMirror type) throws InvalidTypeException { // Primitive if (isPrimitive(type)) { return getPrimitiveType(type); } // Array if (isArrayType(type)) { return getArrayType((ArrayType) type); } // ArrayList if (isArrayListType(type)) { return getArrayListType((DeclaredType) type); } // Sparse ParcelableArray if (isSparseParcelableArray(type)) { return "SparseParcelableArray"; } // Other types if (types.isAssignable(type, bundleType)) { return "Bundle"; } if (isAggregateType(type)) { return getAggregateType(type); } if (types.isAssignable(type, serializableType)) { return "Serializable"; } throw new InvalidTypeException(InvalidTypeException.Container.BUNDLE, type); }
public String getIntentType(TypeMirror type) throws InvalidTypeException { // Primitive if (isPrimitive(type)) { return getPrimitiveType(type); } // Array if (isArrayType(type)) { return getArrayType((ArrayType) type); } // ArrayList if (isArrayListType(type)) { return getArrayListType((DeclaredType) type); } if (types.isAssignable(type, bundleType)) { return "Bundle"; } if (isAggregateType(type)) { return getAggregateType(type); } if (types.isAssignable(type, serializableType)) { return "Serializable"; } throw new InvalidTypeException(InvalidTypeException.Container.INTENT, type); }
public TypeFactory(Elements elementUtils, Types typeUtils) { this.elementUtils = elementUtils; this.typeUtils = typeUtils; iterableType = typeUtils.erasure(elementUtils.getTypeElement(Iterable.class.getCanonicalName()).asType()); collectionType = typeUtils.erasure( elementUtils.getTypeElement(Collection.class.getCanonicalName()).asType()); mapType = typeUtils.erasure(elementUtils.getTypeElement(Map.class.getCanonicalName()).asType()); implementationTypes.put(Iterable.class.getName(), getType(ArrayList.class)); implementationTypes.put(Collection.class.getName(), getType(ArrayList.class)); implementationTypes.put(List.class.getName(), getType(ArrayList.class)); implementationTypes.put(Set.class.getName(), getType(HashSet.class)); implementationTypes.put(SortedSet.class.getName(), getType(TreeSet.class)); implementationTypes.put(NavigableSet.class.getName(), getType(TreeSet.class)); implementationTypes.put(Map.class.getName(), getType(HashMap.class)); implementationTypes.put(SortedMap.class.getName(), getType(TreeMap.class)); implementationTypes.put(NavigableMap.class.getName(), getType(TreeMap.class)); implementationTypes.put(ConcurrentMap.class.getName(), getType(ConcurrentHashMap.class)); implementationTypes.put( ConcurrentNavigableMap.class.getName(), getType(ConcurrentSkipListMap.class)); }
private static DeclaredType findMapTypeDeclaration( TypeMirror typeMirror, EnunciateJacksonContext context) { if (!(typeMirror instanceof DeclaredType)) { return null; } DeclaredType declaredType = (DeclaredType) typeMirror; TypeElement element = (TypeElement) declaredType.asElement(); String fqn = element.getQualifiedName().toString(); if (Map.class.getName().equals(fqn)) { return declaredType; } AdapterType adapterType = JacksonUtil.findAdapterType(element, context); if (adapterType != null) { return findMapTypeDeclaration(adapterType.getAdaptingType(), context); } DeclaredType mapType = null; Types typeUtils = context.getContext().getProcessingEnvironment().getTypeUtils(); List<? extends TypeMirror> supers = typeUtils.directSupertypes(declaredType); for (TypeMirror superInterface : supers) { mapType = findMapTypeDeclaration(superInterface, context); if (mapType != null) { break; } } return mapType; }
private boolean isSparseParcelableArray(TypeMirror type) { if (types.isAssignable(types.erasure(type), sparseArrayType) && type instanceof DeclaredType) { List<? extends TypeMirror> typeArguments = ((DeclaredType) type).getTypeArguments(); if (typeArguments.size() == 1) { return types.isAssignable(typeArguments.get(0), parcelableType); } } return false; }
@Test public void wildcardMirrorExtendsType() throws Exception { Types types = getTypes(); Elements elements = getElements(); TypeMirror charSequence = elements.getTypeElement(CharSequence.class.getName()).asType(); WildcardType wildcard = types.getWildcardType(charSequence, null); TypeName type = TypeName.get(wildcard); assertThat(type.toString()).isEqualTo("? extends java.lang.CharSequence"); }
@Test public void wildcardMirrorSuperType() throws Exception { Types types = getTypes(); Elements elements = getElements(); TypeMirror string = elements.getTypeElement(String.class.getName()).asType(); WildcardType wildcard = types.getWildcardType(null, string); TypeName type = TypeName.get(wildcard); assertThat(type.toString()).isEqualTo("? super java.lang.String"); }
private String getAggregateType(TypeMirror type) throws InvalidTypeException { if (types.isAssignable(type, stringType)) { // String is subtype of CharSequence should go first return "String"; } if (types.isAssignable(type, charSequenceType)) { return "CharSequence"; } if (types.isAssignable(type, parcelableType)) { return "Parcelable"; } throw new InvalidTypeException(type); }
private boolean isPrimitiveWrapper(TypeMirror type) { Types types = context.getEnvironment().getTypeUtils(); for (TypeKind kind : TypeKind.values()) { if (!kind.isPrimitive()) { continue; } if (ElementUtils.typeEquals(type, types.boxedClass(types.getPrimitiveType(kind)).asType())) { return true; } } return false; }
/** * Returns the Type that represents the declared Class type of the given type. For primitive * types, the boxed class will be used. Examples: * * <ul> * <li>If type represents {@code java.lang.Integer}, it will return the type that represents * {@code Class<Integer>}. * <li>If type represents {@code int}, it will return the type that represents {@code * Class<Integer>}. * </ul> * * @param type the type to return the declared class type for * @return the type representing {@code Class<type>}. */ public Type classTypeOf(Type type) { TypeMirror typeToUse; if (type.isVoid()) { return null; } else if (type.isPrimitive()) { typeToUse = typeUtils.boxedClass((PrimitiveType) type.getTypeMirror()).asType(); } else { typeToUse = type.getTypeMirror(); } return getType( typeUtils.getDeclaredType(elementUtils.getTypeElement("java.lang.Class"), typeToUse)); }
public ErrorDescription[] check(JPAProblemContext ctx, AttributeWrapper attrib) { if (!(attrib.getModelElement() instanceof Basic)) { return null; } TreeUtilities treeUtils = ctx.getCompilationInfo().getTreeUtilities(); Types types = ctx.getCompilationInfo().getTypes(); TypeMirror attrType = attrib.getType(); TypeMirror typeSerializable = treeUtils.parseType( "java.io.Serializable", // NOI18N ctx.getJavaClass()); TypeMirror typeEnum = treeUtils.parseType( "java.lang.Enum", // NOI18N ctx.getJavaClass()); TypeMirror typeCollection = treeUtils.parseType( "java.util.Collection", // NOI18N ctx.getJavaClass()); if (types.isAssignable(attrType, typeSerializable) || types.isAssignable(attrType, typeEnum) || types.isAssignable(attrType, typeCollection)) { return null; } for (String typeName : fixedBasicTypes) { TypeMirror type = treeUtils.parseType(typeName, ctx.getJavaClass()); if (type != null && types.isSameType(attrType, type)) { return null; } } if (Utilities.hasAnnotation(attrib.getJavaElement(), JPAAnnotations.ELEMENT_COLLECTION)) { // according to annotation it's not basic type and need to be verified in appropriate // validator return null; } return new ErrorDescription[] { Rule.createProblem( attrib.getJavaElement(), ctx, NbBundle.getMessage(ValidBasicType.class, "MSG_ValidBasicType")) }; }
private boolean isArrayListType(TypeMirror type) { if (types.isAssignable(types.erasure(type), arrayListType)) { List<? extends TypeMirror> typeArguments = ((DeclaredType) type).getTypeArguments(); if (typeArguments.size() == 1) { TypeMirror arg = typeArguments.get(0); if (types.isAssignable(arg, integerType)) { return true; } if (isAggregateType(arg)) { return true; } } } return false; }
@Override public boolean canContain(DataModelMirror other) { Precondition.checkMustNotBeNull(other, "other"); // $NON-NLS-1$ if (other instanceof ConcreteDataModelMirror) { ConcreteDataModelMirror that = (ConcreteDataModelMirror) other; return environment.getTypeUtils().isSameType(this.type, that.type); } if (other instanceof PartialDataModelMirror) { PartialDataModelMirror that = (PartialDataModelMirror) other; Types typeUtils = environment.getTypeUtils(); return typeUtils.isSubtype(this.type, that.type.getUpperBound()) && typeUtils.isSubtype(that.type.getLowerBound(), this.type); } return false; }
@Override @DefinedBy(Api.LANGUAGE_MODEL) public Void visitDeclared(DeclaredType t, Types types) { t.asElement().getKind(); // ensure class exists for (TypeMirror st : types.directSupertypes(t)) visit(st, types); return null; }
/** 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 Set<ConstraintCheckError> checkAnnotationValue( TypeElement element, AnnotationMirror annotation) { Set<ConstraintCheckError> errors = CollectionHelper.newHashSet(); AnnotationValue value = annotationApiHelper.getAnnotationValue(annotation, "value"); TypeMirror valueType = (TypeMirror) value.getValue(); TypeElement valueElement = (TypeElement) typeUtils.asElement(valueType); if (valueElement.getKind().isInterface() || valueElement.getModifiers().contains(Modifier.ABSTRACT)) { errors.add( new ConstraintCheckError( element, annotation, "GROUP_SEQUENCE_PROVIDER_ANNOTATION_VALUE_MUST_BE_AN_IMPLEMENTATION_CLASS")); } else { // the TypeElement hosting the annotation is a concrete implementation of the // DefaultGroupSequenceProvider // interface. In that case, we need to check that it has a public default constructor. if (!hasPublicDefaultConstructor(valueElement)) { errors.add( new ConstraintCheckError( element, annotation, "GROUP_SEQUENCE_PROVIDER_ANNOTATION_VALUE_CLASS_MUST_HAVE_DEFAULT_CONSTRUCTOR", valueType)); } } TypeMirror genericProviderType = retrieveGenericProviderType(valueType); if (!typeUtils.isSubtype(element.asType(), genericProviderType)) { errors.add( new ConstraintCheckError( element, annotation, "GROUP_SEQUENCE_PROVIDER_ANNOTATION_VALUE_DEFINED_PROVIDER_CLASS_WITH_WRONG_TYPE", genericProviderType, element.asType())); } return errors; }
private String getArrayListType(DeclaredType type) throws InvalidTypeException { TypeMirror arg = type.getTypeArguments().get(0); if (types.isAssignable(arg, integerType)) { return "IntegerArrayList"; } try { return getAggregateType(arg).concat("ArrayList"); } catch (InvalidTypeException e) { throw new InvalidTypeException(type); } }
/** * Converts any collection type, e.g. {@code List<T>} to {@code Collection<T>} and any map type, * e.g. {@code HashMap<K,V>} to {@code Map<K,V>}. * * @param collectionOrMap any collection or map type * @return the type representing {@code Collection<T>} or {@code Map<K,V>}, if the argument type * is a subtype of {@code Collection<T>} or of {@code Map<K,V>} respectively. */ public Type asCollectionOrMap(Type collectionOrMap) { List<Type> originalParameters = collectionOrMap.getTypeParameters(); TypeMirror[] originalParameterMirrors = new TypeMirror[originalParameters.size()]; int i = 0; for (Type param : originalParameters) { originalParameterMirrors[i++] = param.getTypeMirror(); } if (collectionOrMap.isCollectionType() && !"java.util.Collection".equals(collectionOrMap.getFullyQualifiedName())) { return getType( typeUtils.getDeclaredType( elementUtils.getTypeElement("java.util.Collection"), originalParameterMirrors)); } else if (collectionOrMap.isMapType() && !"java.util.Map".equals(collectionOrMap.getFullyQualifiedName())) { return getType( typeUtils.getDeclaredType( elementUtils.getTypeElement("java.util.Map"), originalParameterMirrors)); } return collectionOrMap; }
/** * Check shareable components for serializability. * * @param round The round environment. */ private void checkShareableComponents(RoundEnvironment round) { Set<? extends Element> elts = round.getElementsAnnotatedWith(Shareable.class); note("processing %d shareable elements", elts.size()); TypeMirror serializable = elementUtils.getTypeElement("java.io.Serializable").asType(); for (Element elt : elts) { note("examining %s", elt); TypeMirror type = elt.asType(); if (typeUtils.isAssignable(type, serializable)) { note("shareable type %s is serializable", type); } else { warning(elt, "shareable type %s is not serializable", type); } } }
public ValidateDescriptor(ModelDescriptor modelDescriptor, Element field) { super(modelDescriptor, field); this.validateIf = field.getAnnotation(ValidateIf.class); this.validateIfValue = field.getAnnotation(ValidateIfValue.class); ProcessingEnvironment processingEnv = modelDescriptor.getProcessingEnvironment(); Types typeUtils = processingEnv.getTypeUtils(); this.isMethodValidation = getField().getKind().equals(ElementKind.METHOD); if (this.isMethodValidation) { // Make sure our method validation returns a boolean value if (!((ExecutableElement) this.field).getReturnType().getKind().equals(TypeKind.BOOLEAN)) { modelDescriptor .getMessager() .printMessage( Diagnostic.Kind.ERROR, "Methods annotated with @Validate must return a boolean value!", field); } methodAnnotation = getField().getAnnotation(Validate.class); if (this.methodAnnotation == null) { modelDescriptor .getMessager() .printMessage(Diagnostic.Kind.ERROR, "Could not retrieve method validation annotation"); } } else { this.isList = typeUtils.isAssignable( field.asType(), typeUtils.getDeclaredType( processingEnv .getElementUtils() .getTypeElement(ListContainer.class.getCanonicalName()), typeUtils.getWildcardType(null, null))); } }
private TypeMirror getPrimitiveType(Class<?> primitiveType) { return primitiveType == byte.class ? typeUtils.getPrimitiveType(TypeKind.BYTE) : primitiveType == short.class ? typeUtils.getPrimitiveType(TypeKind.SHORT) : primitiveType == int.class ? typeUtils.getPrimitiveType(TypeKind.INT) : primitiveType == long.class ? typeUtils.getPrimitiveType(TypeKind.LONG) : primitiveType == float.class ? typeUtils.getPrimitiveType(TypeKind.FLOAT) : primitiveType == double.class ? typeUtils.getPrimitiveType(TypeKind.DOUBLE) : primitiveType == boolean.class ? typeUtils.getPrimitiveType(TypeKind.BOOLEAN) : primitiveType == char.class ? typeUtils.getPrimitiveType(TypeKind.CHAR) : typeUtils.getPrimitiveType(TypeKind.VOID); }
private boolean needToCastAggregateType(TypeMirror type) throws InvalidTypeException { if (types.isAssignable(type, charSequenceType)) { return !types.isSameType(type, charSequenceType); } if (types.isAssignable(type, stringType)) { return !types.isSameType(type, stringType); } if (types.isAssignable(type, parcelableType)) { return !types.isSameType(type, parcelableType); } throw new InvalidTypeException(type); }
private List<MapperReference> initReferencedMappers( TypeElement element, MapperConfiguration mapperConfig) { List<MapperReference> result = new LinkedList<MapperReference>(); List<String> variableNames = new LinkedList<String>(); for (TypeMirror usedMapper : mapperConfig.uses()) { DefaultMapperReference mapperReference = DefaultMapperReference.getInstance( typeFactory.getType(usedMapper), MapperPrism.getInstanceOn(typeUtils.asElement(usedMapper)) != null, typeFactory, variableNames); result.add(mapperReference); variableNames.add(mapperReference.getVariableName()); } return result; }
/** * Formats an ExecutableElement as if it were contained within the container, if the container is * present. */ public String format(ExecutableElement method, Optional<DeclaredType> container) { StringBuilder builder = new StringBuilder(); TypeElement type = MoreElements.asType(method.getEnclosingElement()); ExecutableType executableType = MoreTypes.asExecutable(method.asType()); if (container.isPresent()) { executableType = MoreTypes.asExecutable(types.asMemberOf(container.get(), method)); type = MoreElements.asType(container.get().asElement()); } // TODO(cgruber): AnnotationMirror formatter. List<? extends AnnotationMirror> annotations = method.getAnnotationMirrors(); if (!annotations.isEmpty()) { Iterator<? extends AnnotationMirror> annotationIterator = annotations.iterator(); for (int i = 0; annotationIterator.hasNext(); i++) { if (i > 0) { builder.append(' '); } builder.append(ErrorMessages.format(annotationIterator.next())); } builder.append(' '); } builder.append(nameOfType(executableType.getReturnType())); builder.append(' '); builder.append(type.getQualifiedName()); builder.append('.'); builder.append(method.getSimpleName()); builder.append('('); checkState(method.getParameters().size() == executableType.getParameterTypes().size()); Iterator<? extends VariableElement> parameters = method.getParameters().iterator(); Iterator<? extends TypeMirror> parameterTypes = executableType.getParameterTypes().iterator(); for (int i = 0; parameters.hasNext(); i++) { if (i > 0) { builder.append(", "); } appendParameter(builder, parameters.next(), parameterTypes.next()); } builder.append(')'); return builder.toString(); }
private Type getImplementationType(TypeMirror mirror) { if (mirror.getKind() != TypeKind.DECLARED) { return null; } DeclaredType declaredType = (DeclaredType) mirror; Type implementationType = implementationTypes.get( ((TypeElement) declaredType.asElement()).getQualifiedName().toString()); if (implementationType != null) { return new Type( typeUtils, elementUtils, this, typeUtils.getDeclaredType( implementationType.getTypeElement(), declaredType.getTypeArguments().toArray(new TypeMirror[] {})), implementationType.getTypeElement(), getTypeParameters(mirror, true), null, null, implementationType.getPackageName(), implementationType.getName(), implementationType.getFullyQualifiedName(), implementationType.isInterface(), implementationType.isEnumType(), implementationType.isIterableType(), implementationType.isCollectionType(), implementationType.isMapType(), isImported(implementationType.getName(), implementationType.getFullyQualifiedName())); } return null; }
/** * Get the ExecutableType for given method as part of usedMapper. Possibly parameterized types in * method declaration will be evaluated to concrete types then. * * @param includingType the type on which's scope the method type shall be evaluated * @param method the method * @return the ExecutableType representing the method as part of usedMapper */ public ExecutableType getMethodType(TypeElement includingType, ExecutableElement method) { DeclaredType asType = (DeclaredType) replaceTypeElementIfNecessary(elementUtils, includingType).asType(); TypeMirror asMemberOf = typeUtils.asMemberOf(asType, method); return (ExecutableType) asMemberOf; }
private Decorator getDecorator( TypeElement element, List<SourceMethod> methods, String implName, String implPackage) { DecoratedWithPrism decoratorPrism = DecoratedWithPrism.getInstanceOn(element); if (decoratorPrism == null) { return null; } TypeElement decoratorElement = (TypeElement) typeUtils.asElement(decoratorPrism.value()); if (!typeUtils.isAssignable(decoratorElement.asType(), element.asType())) { messager.printMessage(element, decoratorPrism.mirror, Message.DECORATOR_NO_SUBTYPE); } List<MappingMethod> mappingMethods = new ArrayList<MappingMethod>(methods.size()); for (SourceMethod mappingMethod : methods) { boolean implementationRequired = true; for (ExecutableElement method : ElementFilter.methodsIn(decoratorElement.getEnclosedElements())) { if (elementUtils.overrides(method, mappingMethod.getExecutable(), decoratorElement)) { implementationRequired = false; break; } } Type declaringMapper = mappingMethod.getDeclaringMapper(); if (implementationRequired && !(mappingMethod.isDefault() || mappingMethod.isStatic())) { if ((declaringMapper == null) || declaringMapper.equals(typeFactory.getType(element))) { mappingMethods.add(new DelegatingMethod(mappingMethod)); } } } boolean hasDelegateConstructor = false; boolean hasDefaultConstructor = false; for (ExecutableElement constructor : ElementFilter.constructorsIn(decoratorElement.getEnclosedElements())) { if (constructor.getParameters().isEmpty()) { hasDefaultConstructor = true; } else if (constructor.getParameters().size() == 1) { if (typeUtils.isAssignable(element.asType(), first(constructor.getParameters()).asType())) { hasDelegateConstructor = true; } } } if (!hasDelegateConstructor && !hasDefaultConstructor) { messager.printMessage(element, decoratorPrism.mirror, Message.DECORATOR_CONSTRUCTOR); } Decorator decorator = new Decorator.Builder() .elementUtils(elementUtils) .typeFactory(typeFactory) .mapperElement(element) .decoratorPrism(decoratorPrism) .methods(mappingMethods) .hasDelegateConstructor(hasDelegateConstructor) .options(options) .versionInformation(versionInformation) .implName(implName) .implPackage(implPackage) .extraImports(getExtraImports(element)) .build(); return decorator; }
public Type getType(TypeMirror mirror) { if (mirror.getKind() == TypeKind.ERROR) { throw new AnnotationProcessingException("Encountered erroneous type " + mirror); } Type implementationType = getImplementationType(mirror); boolean isIterableType = typeUtils.isSubtype(mirror, iterableType); boolean isCollectionType = typeUtils.isSubtype(mirror, collectionType); boolean isMapType = typeUtils.isSubtype(mirror, mapType); boolean isEnumType; boolean isInterface; String name; String packageName; String qualifiedName; TypeElement typeElement; Type componentType; if (mirror.getKind() == TypeKind.DECLARED) { DeclaredType declaredType = (DeclaredType) mirror; isEnumType = declaredType.asElement().getKind() == ElementKind.ENUM; isInterface = declaredType.asElement().getKind() == ElementKind.INTERFACE; name = declaredType.asElement().getSimpleName().toString(); typeElement = (TypeElement) declaredType.asElement(); if (typeElement != null) { packageName = elementUtils.getPackageOf(typeElement).getQualifiedName().toString(); qualifiedName = typeElement.getQualifiedName().toString(); } else { packageName = null; qualifiedName = name; } componentType = null; } else if (mirror.getKind() == TypeKind.ARRAY) { TypeMirror componentTypeMirror = getComponentType(mirror); if (componentTypeMirror.getKind() == TypeKind.DECLARED) { DeclaredType declaredType = (DeclaredType) componentTypeMirror; TypeElement componentTypeElement = (TypeElement) declaredType.asElement(); name = componentTypeElement.getSimpleName().toString() + "[]"; packageName = elementUtils.getPackageOf(componentTypeElement).getQualifiedName().toString(); qualifiedName = componentTypeElement.getQualifiedName().toString() + "[]"; } else { name = mirror.toString(); packageName = null; qualifiedName = name; } isEnumType = false; isInterface = false; typeElement = null; componentType = getType(componentTypeMirror); } else { isEnumType = false; isInterface = false; name = mirror.toString(); packageName = null; qualifiedName = name; typeElement = null; componentType = null; } return new Type( typeUtils, elementUtils, this, mirror, typeElement, getTypeParameters(mirror, false), implementationType, componentType, packageName, name, qualifiedName, isInterface, isEnumType, isIterableType, isCollectionType, isMapType, isImported(name, qualifiedName)); }