/** * Check if the given class or any of its super classes have a super method with the given name. * Private methods are ignored since the generated subclass can't call super on those. */ protected boolean hasSuperMethod(TypeElement classElement, Element attribute) { if (!Utils.isEpoxyModel(classElement.asType())) { return false; } for (Element subElement : classElement.getEnclosedElements()) { if (subElement.getKind() == ElementKind.METHOD) { ExecutableElement method = (ExecutableElement) subElement; if (!method.getModifiers().contains(Modifier.PRIVATE) && method.getSimpleName().toString().equals(attribute.getSimpleName().toString()) && method.getParameters().size() == 1 && method.getParameters().get(0).asType().equals(attribute.asType())) { return true; } } } Element superClass = typeUtils.asElement(classElement.getSuperclass()); return (superClass instanceof TypeElement) && hasSuperMethod((TypeElement) superClass, attribute); }
@NonNull public Element fromConfigDelegateMethod(@NonNull ExecutableElement method) { return new DelegateMethod.Config(method.getSimpleName().toString(), TypeName.get(method.getReturnType()), getAnnotations(method).getLeft(), method.getParameters().stream().map(p -> ParameterSpec.builder(TypeName.get(p.asType()), p.getSimpleName().toString()).build()).collect(Collectors.toList()), method.getTypeParameters().stream().map(TypeVariableName::get).collect(Collectors.toList()), method.getModifiers(), elements.getDocComment(method)); }
public boolean requiredAuthentication(ExecutableElement executableElement) { RequiresAuthentication basicAuthAnnotation = executableElement.getAnnotation(RequiresAuthentication.class); if (basicAuthAnnotation == null) { basicAuthAnnotation = executableElement.getEnclosingElement().getAnnotation(RequiresAuthentication.class); } return basicAuthAnnotation != null; }
private String getMethodName(ExecutableElement element) { String returnType = element.getReturnType().toString(); String simpleName = element.getSimpleName().toString(); return returnType + " " + simpleName; }
private boolean checkHasNoErrors(ExecutableElement element, Messager messager) { if (element.getModifiers().contains(Modifier.STATIC)) { messager.printMessage(Diagnostic.Kind.ERROR, "Subscriber method must not be static", element); return false; } if (!element.getModifiers().contains(Modifier.PUBLIC)) { messager.printMessage(Diagnostic.Kind.ERROR, "Subscriber method must be public", element); return false; } List<? extends VariableElement> parameters = ((ExecutableElement) element).getParameters(); if (parameters.size() != 1) { messager.printMessage(Diagnostic.Kind.ERROR, "Subscriber method must have exactly 1 parameter", element); return false; } return true; }
throws Exception { if (!(element instanceof ExecutableElement) || element.getKind() != METHOD) { throw new IllegalStateException( String.format("@%s annotation must be on a method.", annotationClass.getSimpleName())); TypeElement enclosingElement = (TypeElement) element.getEnclosingElement(); Annotation annotation = element.getAnnotation(annotationClass); Method annotationValue = annotationClass.getDeclaredMethod("value"); if (annotationValue.getReturnType() != int[].class) { String name = executableElement.getSimpleName().toString(); boolean required = isListenerRequired(executableElement); annotationClass.getSimpleName(), id, enclosingElement.getQualifiedName(), List<? extends VariableElement> methodParameters = executableElement.getParameters(); if (methodParameters.size() > method.parameters().length) { error(element, "@%s methods can have at most %s parameter(s). (%s.%s)", TypeMirror returnType = executableElement.getReturnType(); if (returnType instanceof TypeVariable) { TypeVariable typeVariable = (TypeVariable) returnType; returnType = typeVariable.getUpperBound();
switch (providerMethod.getEnclosingElement().getKind()) { case CLASS: break; // valid, move along continue; || methodModifiers.contains(STATIC)) { error("@Provides methods must not be private, abstract or static: " + type.getQualifiedName() + "." + providerMethod, providerMethod); continue; if (!providerMethodAsExecutable.getThrownTypes().isEmpty()) { error("@Provides methods must not have a throws clause: " + type.getQualifiedName() + "." + providerMethod, providerMethod); TypeMirror returnType = types.erasure(providerMethodAsExecutable.getReturnType()); if (!returnType.getKind().equals(TypeKind.ERROR)) { TypeElement invalidTypeElement = elementUtils.getTypeElement(invalidTypeName); if (invalidTypeElement != null && types.isSameType(returnType, types.erasure(invalidTypeElement.asType()))) { TypeMirror objectType = elementUtils.getTypeElement("java.lang.Object").asType();
@Override public void process(Element element, EComponentWithViewSupportHolder holder) throws Exception { String methodName = element.getSimpleName().toString(); List<? extends VariableElement> parameters = executableElement.getParameters(); TypeMirror parameterType = parameter.asType(); if (CanonicalNameConstants.EDITABLE.equals(parameterType.toString())) { editableParameterPosition = i; } else { TypeMirror textViewType = annotationHelper.typeElementFromQualifiedName(CanonicalNameConstants.TEXT_VIEW).asType(); if (annotationHelper.isSubtype(parameterType, textViewType)) { viewParameterPosition = i;
/** * 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()); } }
List<TypeElement> enclosedTypes = ElementFilter.typesIn(elem.getEnclosedElements()); for (TypeElement enclosedType : enclosedTypes) { imports.add(enclosedType.getQualifiedName().toString()); modelBuilder.documentType(elem, elementUtils.getDocComment(elem), imports); for (Element memberElement : ElementFilter.methodsIn(elem.getEnclosedElements())) { try { ExecutableElement methodElement = (ExecutableElement) memberElement; Implementation implementation = memberElement.getAnnotation(Implementation.class); for (Modifier modifier : memberElement.getModifiers()) { documentedMethod.modifiers.add(modifier.toString()); documentedMethod.maxSdk = sdkOrNull(implementation.maxSdk()); for (VariableElement variableElement : methodElement.getParameters()) { documentedMethod.params.add(variableElement.toString()); documentedMethod.returnType = methodElement.getReturnType().toString(); for (TypeMirror typeMirror : methodElement.getThrownTypes()) { documentedMethod.exceptions.add(typeMirror.toString()); String docMd = elementUtils.getDocComment(methodElement); if (docMd != null) { documentedMethod.setDocumentation(docMd);
@Override public Optional<ExecutableElement> factoryMethod() { Optional<ExecutableElement> staticFactory = ElementFilter.methodsIn(element().getEnclosedElements()).stream() .filter(element -> element.getModifiers().contains(Modifier.STATIC)) .filter(element -> element.getSimpleName().toString().equalsIgnoreCase("create")) .filter(element -> element.getParameters().size() > 0) .filter(element -> element.getReturnType().equals(element().asType())) .findAny(); Optional<ExecutableElement> constructor = ElementFilter.constructorsIn(element().getEnclosedElements()).stream() .filter(element -> element.getParameters().size() > 0) .findAny(); return staticFactory.isPresent() ? staticFactory : constructor; }
@Override public Iterable<? extends Completion> getCompletions(Element annotated, AnnotationMirror annotation, ExecutableElement attr, String userText) { if (processingEnv == null || annotated == null || !annotated.getKind().isClass()) { return Collections.emptyList(); || !"org.openide.util.lookup.ServiceProvider".contentEquals(((TypeElement) annotation.getAnnotationType().asElement()).getQualifiedName())) { return Collections.emptyList(); if (!"service".contentEquals(attr.getSimpleName())) { return Collections.emptyList(); TypeElement jlObject = processingEnv.getElementUtils().getTypeElement("java.lang.Object"); TypeElement c = toProcess.remove(0); result.add(new TypeCompletion(c.getQualifiedName().toString() + ".class")); parents.add(c.getSuperclass()); parents.addAll(c.getInterfaces()); if (tm == null || tm.getKind() != TypeKind.DECLARED) { continue;
private boolean ensureTypeConverterClassValid(TypeMirror typeConverterClassMirror, Elements elements, Types types) { TypeElement typeConverterElement = elements.getTypeElement(typeConverterClassMirror.toString()); for (TypeMirror iface : element.getInterfaces()) { if (types.erasure(iface).toString().equals(TypeConverter.class.getCanonicalName())) { isTypeConverterType = true; TypeMirror superClassMirror = element.getSuperclass(); if (superClassMirror != null) { superClassMirror = types.erasure(superClassMirror); element = elements.getTypeElement(superClassMirror.toString()); } else { element = null; List<? extends Element> enclosedElements = typeConverterElement.getEnclosedElements(); for (Element enclosedElement : enclosedElements) { ElementKind enclosedElementKind = enclosedElement.getKind(); if (enclosedElementKind == ElementKind.CONSTRUCTOR) { constructorIsDeclared = true; if (!enclosedElement.getModifiers().contains(Modifier.PRIVATE)) { ExecutableElement executableElement = (ExecutableElement)enclosedElement; if (executableElement.getParameters().size() == 0) { hasAccessibleConstructor = true;
private static TypeName getMountType(Elements elements, TypeElement element) { TypeElement viewType = elements.getTypeElement(ClassNames.VIEW_NAME); TypeElement drawableType = elements.getTypeElement(ClassNames.DRAWABLE_NAME); for (Element enclosedElement : element.getEnclosedElements()) { if (enclosedElement.getKind() != ElementKind.METHOD) { continue; OnCreateMountContent annotation = enclosedElement.getAnnotation(OnCreateMountContent.class); if (annotation != null) { if (annotation.mountingType() == MountingType.VIEW) { return ClassNames.COMPONENT_LIFECYCLE_MOUNT_TYPE_DRAWABLE; TypeMirror returnType = ((ExecutableElement) enclosedElement).getReturnType(); while (returnType.getKind() != TypeKind.NONE && returnType.getKind() != TypeKind.VOID) { final TypeElement returnElement = (TypeElement) ((DeclaredType) returnType).asElement(); returnType = returnElement.getSuperclass(); } catch (RuntimeException e) { throw new ComponentsProcessingException(
private void addMethods(TypeElement interfaceClazz, TypeSpec.Builder classBuilder) { List<? extends Element> elements = interfaceClazz.getEnclosedElements(); if (elements != null && !elements.isEmpty()) { for (Element e : elements) { if (ElementKind.METHOD.equals(e.getKind())) { ExecutableElement method = (ExecutableElement) e; MethodSpec.Builder methodBuilder = MethodSpec.methodBuilder(method.getSimpleName().toString() + ASYNC) .addModifiers(Modifier.PUBLIC, Modifier.ABSTRACT).returns(ResponseFuture.class) .addTypeVariables(getTypeNames(method.getTypeParameters())); // add method params List<? extends VariableElement> vars = method.getParameters(); for (VariableElement var : vars) { methodBuilder.addParameter(ParameterSpec.builder(TypeName.get(var.asType()), var.getSimpleName().toString()) .build()); } classBuilder.addMethod(methodBuilder.build()); } } } }
@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(); }
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 void handleBaseBuilder() { if (!MoreTypes.isTypeOf(Object.class, baseBuilder.asType())) { final List<ExecutableElement> constructors = ElementFilter.constructorsIn(baseBuilder.getEnclosedElements()); Optional<ExecutableElement> constructor = constructors.stream().filter(c -> c.getParameters().size() == 0).findAny(); if (constructor.isPresent()) { elements.add(modelFactory.fromDelegateConstructor(constructor.get(), false)); } else { constructor = constructors.stream().filter(c -> c.getParameters().size() == 1 && Types.CONTEXT.equals(TypeName.get(c.getParameters().get(0).asType()))).findAny(); if (constructor.isPresent()) { elements.add(modelFactory.fromDelegateConstructor(constructor.get(), true)); } else { final AnnotationMirror mirror = baseAnnotation.getAnnotationMirrors().stream() .filter(m -> MoreTypes.isTypeOf(Configuration.class, m.getAnnotationType())) .findAny().orElseThrow(IllegalArgumentException::new); messager.printMessage(Diagnostic.Kind.ERROR, "Classes used as base builder must have a constructor which takes no arguments, " + "or exactly one argument of type Class", baseAnnotation, mirror, mirror.getElementValues().entrySet().stream() .filter(entry -> entry.getKey().getSimpleName().toString().equals("builderSuperClass")).findAny().map(Map.Entry::getValue).orElse(null)); throw new IllegalArgumentException(); } } handleBaseBuilderMethods(); } }
private boolean hasActivityOptions(TypeElement type, int optionsParamPosition) { if (type == null) { return false; } for (ExecutableElement element : ElementFilter.methodsIn(elementUtils.getAllMembers(type))) { if (element.getSimpleName().contentEquals("startActivity")) { List<? extends VariableElement> parameters = element.getParameters(); if (parameters.size() == optionsParamPosition + 1) { VariableElement parameter = parameters.get(optionsParamPosition); if (parameter.asType().toString().equals(CanonicalNameConstants.BUNDLE)) { return true; } } } } return false; }
public void isPrefMethod(Element element, ElementValidation valid) { if (!element.getKind().equals(ElementKind.METHOD)) { valid.addError("Only methods are allowed in an %s annotated interface"); } else { ExecutableElement executableElement = (ExecutableElement) element; String methodName = executableElement.getSimpleName().toString(); if (executableElement.getParameters().size() > 0) { valid.addError("Method " + methodName + " should have no parameters in an %s annotated interface"); } else { String returnType = executableElement.getReturnType().toString(); if (!VALID_PREF_RETURN_TYPES.contains(returnType)) { valid.addError("Method " + methodName + " should only return preference simple types in an %s annotated interface"); } else { if (INVALID_PREF_METHOD_NAMES.contains(methodName)) { valid.addError("The method name " + methodName + " is forbidden in an %s annotated interface"); } else { return; } } } } valid.invalidate(); }