private boolean isMethodInBaseRequestOptions(ExecutableElement toFind) { // toFind is a method in a GlideExtension whose first argument is a BaseRequestOptions<?> type. // Since we're comparing against methods in BaseRequestOptions itself, we need to drop that // first type. TypeElement requestOptionsType = processingEnvironment .getElementUtils() .getTypeElement(RequestOptionsGenerator.BASE_REQUEST_OPTIONS_QUALIFIED_NAME); List<String> toFindParameterNames = getComparableParameterNames(toFind, true /*skipFirst*/); String toFindSimpleName = toFind.getSimpleName().toString(); for (Element element : requestOptionsType.getEnclosedElements()) { if (element.getKind() != ElementKind.METHOD) { continue; } ExecutableElement inBase = (ExecutableElement) element; if (toFindSimpleName.equals(inBase.getSimpleName().toString())) { List<String> parameterNamesInBase = getComparableParameterNames(inBase, false /*skipFirst*/); if (parameterNamesInBase.equals(toFindParameterNames)) { return true; } } } return false; }
private static boolean hasAnnotationWithName(Element element, String simpleName) { for (AnnotationMirror mirror : element.getAnnotationMirrors()) { String annotationName = mirror.getAnnotationType().asElement().getSimpleName().toString(); if (simpleName.equals(annotationName)) { return true; } } return false; }
/** Does not test for multiple qualifiers. This is tested in {@code ValidationProcessor}. */ private static AnnotationMirror getQualifier( List<? extends AnnotationMirror> annotations) { AnnotationMirror qualifier = null; for (AnnotationMirror annotation : annotations) { if (annotation.getAnnotationType().asElement().getAnnotation(Qualifier.class) == null) { continue; } qualifier = annotation; } return qualifier; } }
public TypeMirror getActualTypeOfEnclosingElementOfInjectedElement(GeneratedClassHolder holder, Element param) { DeclaredType enclosingClassType; if (param.getKind() == ElementKind.PARAMETER) { enclosingClassType = (DeclaredType) param.getEnclosingElement().getEnclosingElement().asType(); } else { enclosingClassType = (DeclaredType) param.getEnclosingElement().asType(); } return getActualType(param, enclosingClassType, holder); }
private String getListName(Element element, Element param) { String listName = param.getSimpleName().toString(); if (element.getKind() == ElementKind.PARAMETER) { listName = element.getEnclosingElement().getSimpleName().toString() + "_" + listName; } else if (element.getKind() == ElementKind.METHOD) { listName = element.getSimpleName().toString() + "_" + listName; } return listName; }
private void parseResourceDrawable(Element element, Map<TypeElement, BindingSet.Builder> builderMap, Set<TypeElement> erasedTargetNames) { boolean hasError = false; TypeElement enclosingElement = (TypeElement) element.getEnclosingElement(); // Verify that the target type is Drawable. if (!DRAWABLE_TYPE.equals(element.asType().toString())) { error(element, "@%s field type must be 'Drawable'. (%s.%s)", BindDrawable.class.getSimpleName(), enclosingElement.getQualifiedName(), element.getSimpleName()); hasError = true; } // Verify common generated code restrictions. hasError |= isInaccessibleViaGeneratedCode(BindDrawable.class, "fields", element); hasError |= isBindingInWrongPackage(BindDrawable.class, element); if (hasError) { return; } // Assemble information on the field. String name = element.getSimpleName().toString(); int id = element.getAnnotation(BindDrawable.class).value(); int tint = element.getAnnotation(BindDrawable.class).tint(); Map<Integer, Id> resourceIds = elementToIds(element, BindDrawable.class, new int[] {id, tint}); BindingSet.Builder builder = getOrCreateBindingBuilder(builderMap, enclosingElement); builder.addResource(new FieldDrawableBinding(resourceIds.get(id), name, resourceIds.get(tint))); erasedTargetNames.add(enclosingElement); }
private void parseResourceInt(Element element, Map<TypeElement, BindingSet.Builder> builderMap, Set<TypeElement> erasedTargetNames) { boolean hasError = false; TypeElement enclosingElement = (TypeElement) element.getEnclosingElement(); // Verify that the target type is int. if (element.asType().getKind() != TypeKind.INT) { error(element, "@%s field type must be 'int'. (%s.%s)", BindInt.class.getSimpleName(), enclosingElement.getQualifiedName(), element.getSimpleName()); hasError = true; } // Verify common generated code restrictions. hasError |= isInaccessibleViaGeneratedCode(BindInt.class, "fields", element); hasError |= isBindingInWrongPackage(BindInt.class, element); if (hasError) { return; } // Assemble information on the field. String name = element.getSimpleName().toString(); int id = element.getAnnotation(BindInt.class).value(); Id resourceId = elementToId(element, BindInt.class, id); BindingSet.Builder builder = getOrCreateBindingBuilder(builderMap, enclosingElement); builder.addResource( new FieldResourceBinding(resourceId, name, FieldResourceBinding.Type.INT)); erasedTargetNames.add(enclosingElement); }
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);
public AnnotationMirror getAnnotationMirror() { List<? extends AnnotationMirror> annotationMirrors = element.getAnnotationMirrors(); for (AnnotationMirror annotationMirror : annotationMirrors) { TypeElement annotationElement = (TypeElement) annotationMirror.getAnnotationType().asElement(); if (annotationElement.getQualifiedName().toString().equals(annotationName)) { return annotationMirror; } } return null; }
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 ); }
public void validateRestSimpleParameter(Element element, String requiredClass, String parameterName, ElementValidation validation) { TypeMirror requiredType = annotationHelper.typeElementFromQualifiedName(requiredClass).asType(); DeclaredType paramterType = annotationHelper.extractAnnotationClassParameter(element, annotationHelper.getTarget(), parameterName); if (paramterType != null) { if (annotationHelper.isSubtype(paramterType, requiredType)) { Element parameterElement = paramterType.asElement(); if (parameterElement.getKind().isClass()) { if (!annotationHelper.isAbstract(parameterElement)) { if (parameterElement.getAnnotation(EBean.class) != null) { typeIsValid(EBean.class, paramterType, validation); return; } List<ExecutableElement> constructors = ElementFilter.constructorsIn(parameterElement.getEnclosedElements()); for (ExecutableElement constructor : constructors) { if (annotationHelper.isPublic(constructor) && constructor.getParameters().isEmpty()) { return; } } validation.addError(element, "The " + parameterName + " class must have a public no argument constructor or must be annotated with @EBean"); } else { validation.addError(element, "The " + parameterName + " class must not be abstract"); } } else { validation.addError(element, "The " + parameterName + " class must be a class"); } } else { validation.addError(element, "The " + parameterName + " class must be a subtype of " + requiredClass); } } }
private void writeCreateSubscriberMethods(BufferedWriter writer, List<ExecutableElement> methods, String callPrefix, String myPackage) throws IOException { for (ExecutableElement method : methods) { List<? extends VariableElement> parameters = method.getParameters(); TypeMirror paramType = getParamTypeMirror(parameters.get(0), null); TypeElement paramElement = (TypeElement) processingEnv.getTypeUtils().asElement(paramType); String methodName = method.getSimpleName().toString(); String eventClass = getClassString(paramElement, myPackage) + ".class"; Subscribe subscribe = method.getAnnotation(Subscribe.class); List<String> parts = new ArrayList<>(); parts.add(callPrefix + "(\"" + methodName + "\","); method.getEnclosingElement().getSimpleName() + "." + methodName + "(" + paramElement.getSimpleName() + ")");
public VerifierVisitor(Verifier verifier, Element clzElement) { this.verifier = verifier; Collection<ExecutableElement> shared = new ArrayList<>(); for(Element e : clzElement.getEnclosedElements()) { if (e.getKind() == ElementKind.METHOD && e.getModifiers().containsAll(EnumSet.of(Modifier.STATIC, Modifier.PRIVATE))) { shared.add((ExecutableElement)e); } } btraceServiceTm = verifier.getElementUtils().getTypeElement("com.sun.btrace.services.spi.BTraceService").asType(); runtimeServiceTm = verifier.getElementUtils().getTypeElement("com.sun.btrace.services.spi.RuntimeService").asType(); simpleServiceTm = verifier.getElementUtils().getTypeElement("com.sun.btrace.services.spi.SimpleService").asType(); serviceInjectorTm = verifier.getElementUtils().getTypeElement("com.sun.btrace.services.api.Service").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 String getType(TypeMirror type) { if (type == null) { return null; } if (type instanceof DeclaredType) { DeclaredType declaredType = (DeclaredType) type; Element enclosingElement = declaredType.asElement().getEnclosingElement(); if (enclosingElement != null && enclosingElement instanceof TypeElement) { return getQualifiedName(enclosingElement) + "$" + declaredType.asElement().getSimpleName().toString(); } else { return getQualifiedName(declaredType.asElement()); } } return type.toString(); }
private boolean isVoidLambda(Tree tree) { ExecutableElementTest<Void> test = new ExecutableElementTest<>((e, o) -> !e.isDefault() && !e.getModifiers().contains(STATIC) && "void".equals(e.getReturnType().toString())); return types.asElement(trees.getTypeMirror(trees.getPath(getCurrentPath().getCompilationUnit(), tree))).getEnclosedElements().stream().anyMatch(m -> m.accept(test, null)); }
public boolean requiredAuthentication(ExecutableElement executableElement) { RequiresAuthentication basicAuthAnnotation = executableElement.getAnnotation(RequiresAuthentication.class); if (basicAuthAnnotation == null) { basicAuthAnnotation = executableElement.getEnclosingElement().getAnnotation(RequiresAuthentication.class); } return basicAuthAnnotation != null; }
/** * Get information about constructors of the original class so we can duplicate them in the * generated class and call through to super with the proper parameters */ protected static List<ConstructorInfo> getClassConstructors(TypeElement classElement) { List<ConstructorInfo> constructors = new ArrayList<>(2); for (Element subElement : classElement.getEnclosedElements()) { if (subElement.getKind() == ElementKind.CONSTRUCTOR && !subElement.getModifiers().contains(Modifier.PRIVATE)) { ExecutableElement constructor = ((ExecutableElement) subElement); List<? extends VariableElement> params = constructor.getParameters(); constructors.add(new ConstructorInfo(subElement.getModifiers(), buildParamSpecs(params), constructor.isVarArgs())); } } return constructors; }
private boolean validateElement(Element element) { return element.getKind().isClass() && processingEnv.getTypeUtils().isAssignable(element.asType(), processingEnv.getElementUtils().getTypeElement(INTERCEPTOR_FULL_NAME).asType()); }
public void restInterfaceHasFormConverter(Element element, ElementValidation validation) { Element restInterface = element.getEnclosingElement().getEnclosingElement(); if (restInterface.getAnnotation(Rest.class) == null) { return; } List<DeclaredType> converters = annotationHelper.extractAnnotationClassArrayParameter(restInterface, Rest.class.getCanonicalName(), "converters"); boolean formConverterFound = false; TypeMirror formConverter = annotationHelper.getElementUtils().getTypeElement(FORM_HTTP_MESSAGE_CONVERTER).asType(); for (DeclaredType converter : converters) { if (formConverter != null && annotationHelper.isSubtype(converter, formConverter)) { formConverterFound = true; break; } } if (!formConverterFound) { validation.addError(element, "%s annotated method parameter must be in a @Rest annotated interface which uses at least one " // + FORM_HTTP_MESSAGE_CONVERTER + " (or subtype)"); } }