Refine search
public TypeMirror typeMirror( Class<?> type ) { return elementUtils.getTypeElement( type.getName() ).asType(); }
switch (type.getKind()) { case BOOLEAN: boxedClass = Boolean.class; : elements.getTypeElement(boxedClass.getName()).asType();
/** * 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 Imports(ProcessingEnvironment environment) { super(environment); this.importType = elements.getTypeElement(Generator.Import.class.getCanonicalName()).asType(); }
/** * @return The first element matching the given method in the class's hierarchy, or null if there * is no match. */ static ExecutableElement getMethodOnClass(TypeElement clazz, MethodSpec method, Types typeUtils, Elements elements) { if (clazz.asType().getKind() != TypeKind.DECLARED) { return null; } for (Element subElement : clazz.getEnclosedElements()) { if (subElement.getKind() == ElementKind.METHOD) { ExecutableElement methodElement = ((ExecutableElement) subElement); if (!methodElement.getSimpleName().toString().equals(method.name)) { continue; } if (!areParamsTheSame(methodElement, method, typeUtils, elements)) { continue; } return methodElement; } } TypeElement superClazz = getParentClassElement(clazz, typeUtils); if (superClazz == null) { return null; } return getMethodOnClass(superClazz, method, typeUtils, elements); }
@Override public Optional<TypeMirror> builderType() { Optional<Entity> entityAnnotation = annotationOf(Entity.class); if (entityAnnotation.isPresent()) { Entity entity = entityAnnotation.get(); Elements elements = processingEnvironment.getElementUtils(); TypeMirror mirror = null; try { Class<?> builderClass = entity.builder(); // easiest way to get the class TypeMirror if (builderClass != void.class) { mirror = elements.getTypeElement(builderClass.getName()).asType(); } } catch (MirroredTypeException typeException) { mirror = typeException.getTypeMirror(); } if (mirror != null && mirror.getKind() != TypeKind.VOID) { return Optional.of(mirror); } } if (builderFactoryMethod().isPresent()) { return Optional.of(builderFactoryMethod().get().getReturnType()); } return ElementFilter.typesIn(element().getEnclosedElements()).stream() .filter(element -> element.getSimpleName().toString().contains("Builder")) .map(Element::asType) .filter(Objects::nonNull) .filter(type -> type.getKind() != TypeKind.VOID) .findFirst(); }
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(); }
public void canBePutInABundle(Element element, ElementValidation valid) { TypeMirror typeMirror = element.asType(); String typeString = element.asType().toString(); if (!isKnownBundleCompatibleType(typeString)) { if (typeMirror instanceof ArrayType) { ArrayType arrayType = (ArrayType) element.asType(); typeMirror = arrayType.getComponentType(); } if (typeMirror.getKind() != TypeKind.NONE) { TypeMirror parcelableType = annotationHelper.typeElementFromQualifiedName(CanonicalNameConstants.PARCELABLE).asType(); TypeMirror serializableType = annotationHelper.typeElementFromQualifiedName("java.io.Serializable").asType(); if (typeString.startsWith(CanonicalNameConstants.SPARSE_ARRAY)) { DeclaredType declaredType = (DeclaredType) typeMirror; List<? extends TypeMirror> typeArguments = declaredType.getTypeArguments(); if (typeArguments.size() != 1 || !annotationHelper.isSubtype(typeArguments.get(0), parcelableType)) { valid.addError("Unrecognized type. The type argument of SparseArray should implement Parcelable."); } } else if (!annotationHelper.isSubtype(typeMirror, parcelableType) && !annotationHelper.isSubtype(typeMirror, serializableType) && !parcelerHelper.isParcelType(typeMirror)) { valid.addError("Unrecognized type. Please let your attribute be primitive or implement Serializable or Parcelable or an annotated Parceler bean."); } } } }
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 synchronized void init(final ProcessingEnvironment processingEnv) { super.init(processingEnv); typeUtils = processingEnv.getTypeUtils(); elementUtils = processingEnv.getElementUtils(); actorTypeMirror = elementUtils.getTypeElement(Actor.class.getName()).asType(); actorObserverTypeMirror = elementUtils.getTypeElement(ActorObserver.class.getName()).asType(); }
private Set<String> useProvidedTypesForServices(TypeElement typeElement, ImmutableList<TypeMirror> typesMirrors) { List<String> wrongTypes = Lists.newArrayList(); List<String> types = Lists.newArrayList(); for (TypeMirror typeMirror : typesMirrors) { if (typeMirror.getKind() != TypeKind.DECLARED || !processing().getTypeUtils().isAssignable(typeElement.asType(), typeMirror)) { wrongTypes.add(typeMirror.toString()); } else { types.add(typeMirror.toString()); } } if (!wrongTypes.isEmpty()) { processing().getMessager().printMessage( Diagnostic.Kind.ERROR, "@Metainf.Service(value = {...}) contains types that are not implemented by " + typeElement.getSimpleName() + ": " + wrongTypes, typeElement, AnnotationMirrors.findAnnotation(typeElement.getAnnotationMirrors(), Metainf.Service.class)); } return FluentIterable.from(types).toSet(); }
if (!returnType.getKind().equals(TypeKind.ERROR)) { TypeElement invalidTypeElement = elementUtils.getTypeElement(invalidTypeName); if (invalidTypeElement != null && types.isSameType(returnType, types.erasure(invalidTypeElement.asType()))) { error(String.format("@Provides method must not return %s directly: %s.%s", invalidTypeElement, type.getQualifiedName(), providerMethod), providerMethod); TypeMirror objectType = elementUtils.getTypeElement("java.lang.Object").asType();
private boolean isAssignable(String childClazz, String superClazz) { return processingEnv.getTypeUtils().isAssignable( processingEnv.getElementUtils().getTypeElement(childClazz).asType(), processingEnv.getElementUtils().getTypeElement(superClazz).asType()); } }
private static boolean implementsInterface(Types types, TypeElement element, String interfaceName) { // check name or interfaces if (namesEqual(element, interfaceName)) { return true; } TypeMirror type = element.asType(); while (type != null && type.getKind() != TypeKind.NONE) { TypeElement currentElement = (TypeElement) types.asElement(type); if (currentElement == null) { break; } List<? extends TypeMirror> interfaces = element.getInterfaces(); for (TypeMirror interfaceType : interfaces) { interfaceType = types.erasure(interfaceType); TypeElement typeElement = (TypeElement) types.asElement(interfaceType); if (typeElement != null && implementsInterface(types, typeElement, interfaceName)) { return true; } } type = currentElement.getSuperclass(); } return false; }
/** * Returns the upper bound of {@code type}.<ul> * <li>T -> T * <li>? -> Object * <li>? extends T -> T * <li>? super T -> Object * </ul> */ public static TypeMirror upperBound(Elements elements, TypeMirror type) { if (type.getKind() == TypeKind.WILDCARD) { WildcardType wildcard = (WildcardType) type; type = wildcard.getExtendsBound(); if (type == null) { type = elements.getTypeElement(Object.class.getName()).asType(); } } return type; }
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); }
TypeElement delegateType = elements.getTypeElement("io.requery.meta." + kotlinDelegate); if (delegateType != null) { attributeType = ClassName.get(delegateType); attribute.builderClass(), targetName, typeName); TypeName classType = typeName; if (typeMirror.getKind().isPrimitive()) { TypeName.get(referenced.element().asType()) : nameResolver.typeNameOf(referenced));
@Override public synchronized void init(ProcessingEnvironment processingEnv) { mFiler = processingEnv.getFiler(); mElements = processingEnv.getElementUtils(); mLog = new Logger(processingEnv.getMessager()); mOnRegisterType = TypeName.get(mElements.getTypeElement(Constants.ON_REGISTER_TYPE).asType()); mRegisterType = TypeName.get(mElements.getTypeElement(Constants.REGISTER_TYPE).asType()); mResolver = TypeName.get(mElements.getTypeElement(Constants.RESOLVER_TYPE).asType()); mString = TypeName.get(String.class); }
/** * 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()); }