private boolean isAssignable(String childClazz, String superClazz) { return processingEnv.getTypeUtils().isAssignable( processingEnv.getElementUtils().getTypeElement(childClazz).asType(), processingEnv.getElementUtils().getTypeElement(superClazz).asType()); } }
private String readTemplateResource(TypeElement templateType, SwissArmyKnife knife) throws IOException { PackageElement packageElement = knife.elements.getPackageOf(templateType); return getTemplateText( knife.environment.getFiler(), templateType, packageElement); }
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 final String getPackageName() { PackageElement packageOf = context.getElementUtils().getPackageOf( element ); return context.getElementUtils().getName( packageOf.getQualifiedName() ).toString(); }
TypeMirror verticleType = processingEnv.getElementUtils().getTypeElement(Verticle.class.getName()).asType(); for (Element rootElt : roundEnv.getRootElements()) { Set<Modifier> modifiers = rootElt.getModifiers(); if (rootElt.getKind() == ElementKind.CLASS && !modifiers.contains(Modifier.ABSTRACT) && modifiers.contains(Modifier.PUBLIC) && processingEnv.getTypeUtils().isSubtype(rootElt.asType(), verticleType)) { TypeElement typeElt = (TypeElement) rootElt; for (Element enclosedElt : typeElt.getEnclosedElements()) { if (enclosedElt.getKind() == ElementKind.METHOD) { ExecutableElement methodElt = (ExecutableElement) enclosedElt; if (methodElt.getSimpleName().toString().equals("start") && methodElt.getParameters().isEmpty()) { methodElts.add(methodElt); TypeElement typeElt = (TypeElement) methodElt.getEnclosingElement(); FileObject obj = processingEnv.getFiler().getResource(StandardLocation.SOURCE_PATH, "", typeElt.getQualifiedName().toString().replace('.', '/') + ".java"); File srcFolder = new File(obj.toUri()).getParentFile(); String filename = Case.SNAKE.format(Case.CAMEL.parse(typeElt.getSimpleName().toString())); continue; String folderPath = processingEnv.getElementUtils().getPackageOf(typeElt).getQualifiedName().toString().replace('.', '/'); File dstFolder = new File(new File(outputDir, lang.getExtension()), folderPath); if (dstFolder.exists() || dstFolder.mkdirs()) {
Elements elementUtils = processingEnv.getElementUtils(); Types types = processingEnv.getTypeUtils(); 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()))) { 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();
processingEnv.getTypeUtils().getDeclaredType( processingEnv.getElementUtils().getTypeElement(type.getName().replace('$', '.'))) : null; switch (originatingElement.getKind()) { case CLASS: { String clazz = processingEnv.getElementUtils().getBinaryName((TypeElement) originatingElement).toString(); if (originatingElement.getModifiers().contains(Modifier.ABSTRACT)) { throw new LayerGenerationException(clazz + " must not be abstract", originatingElement, processingEnv, annotation, annotationMethod); if (typeMirror != null && !processingEnv.getTypeUtils().isAssignable(originatingElement.asType(), typeMirror)) { throw new LayerGenerationException(clazz + " is not assignable to " + typeMirror, originatingElement, processingEnv, annotation, annotationMethod); throw new LayerGenerationException(clazz + " is not public", originatingElement, processingEnv, annotation, annotationMethod); if (((TypeElement) originatingElement).getNestingKind().isNested() && !originatingElement.getModifiers().contains(Modifier.STATIC)) { throw new LayerGenerationException(clazz + " is nested but not static", originatingElement, processingEnv, annotation, annotationMethod); String clazz = processingEnv.getElementUtils().getBinaryName((TypeElement) originatingElement.getEnclosingElement()).toString(); String method = originatingElement.getSimpleName().toString(); if (!originatingElement.getModifiers().contains(Modifier.STATIC)) { throw new LayerGenerationException(clazz + "." + method + " must be static", originatingElement, processingEnv, annotation, annotationMethod); if (!((ExecutableElement) originatingElement).getParameters().isEmpty()) { throw new LayerGenerationException(clazz + "." + method + " must not take arguments", originatingElement, processingEnv, annotation, annotationMethod); if (typeMirror != null && !processingEnv.getTypeUtils().isAssignable(((ExecutableElement) originatingElement).getReturnType(), typeMirror)) { throw new LayerGenerationException(clazz + "." + method + " is not assignable to " + typeMirror, originatingElement, processingEnv, annotation, annotationMethod);
@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; TypeElement type = (TypeElement) processingEnv.getTypeUtils().asElement(tm);
TypeMirror type, String path, int position, String... supersedes ) { if (el.getKind() != ElementKind.CLASS) { processingEnv.getMessager().printMessage(Kind.ERROR, annotation.getName() + " is not applicable to a " + el.getKind(), el); return; if (el.getEnclosingElement().getKind() == ElementKind.CLASS && !el.getModifiers().contains(Modifier.STATIC)) { processingEnv.getMessager().printMessage(Kind.ERROR, "Inner class needs to be static to be annotated with @ServiceProvider", el); return; String impl = processingEnv.getElementUtils().getBinaryName(clazz).toString(); String xface = processingEnv.getElementUtils().getBinaryName((TypeElement) processingEnv.getTypeUtils().asElement(type)).toString(); if (!processingEnv.getTypeUtils().isAssignable(clazz.asType(), type)) { AnnotationMirror ann = findAnnotationMirror(clazz, annotation); processingEnv.getMessager().printMessage(Kind.ERROR, impl + " is not assignable to " + xface,
private void processJsonObjectAnnotation(Element element, Map<String, JsonObjectHolder> jsonObjectMap, Elements elements, Types types) { TypeElement typeElement = (TypeElement)element; if (element.getModifiers().contains(PRIVATE)) { error(element, "%s: %s annotation can't be used on private classes.", typeElement.getQualifiedName(), JsonObject.class.getSimpleName()); String packageName = elements.getPackageOf(typeElement).getQualifiedName().toString(); String objectClassName = TypeUtils.getSimpleClassName(typeElement, packageName); String injectedSimpleClassName = objectClassName + Constants.MAPPER_CLASS_SUFFIX; boolean abstractClass = element.getModifiers().contains(ABSTRACT); List<? extends TypeParameterElement> parentTypeParameters = new ArrayList<>(); List<String> parentUsedTypeParameters = new ArrayList<>(); TypeName parentClassName = null; String superclassName = superclass.toString(); int indexOfTypeParamStart = superclassName.indexOf("<"); if (indexOfTypeParamStart > 0) { while (superclass.getKind() != TypeKind.NONE) { TypeElement superclassElement = (TypeElement)types.asElement(superclass); if (superclassElement.getAnnotation(JsonObject.class) != null) { String superclassPackageName = elements.getPackageOf(superclassElement).getQualifiedName().toString(); parentClassName = ClassName.get(superclassPackageName, TypeUtils.getSimpleClassName(superclassElement, superclassPackageName)); break; JsonObject annotation = element.getAnnotation(JsonObject.class);
List<TypeElement> enclosedTypes = ElementFilter.typesIn(elem.getEnclosedElements()); for (TypeElement enclosedType : enclosedTypes) { imports.add(enclosedType.getQualifiedName().toString()); Elements elementUtils = env.getElementUtils(); 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 static String getGetter(Element element, Elements elements) { TypeElement enclosingElement = (TypeElement) element.getEnclosingElement(); TypeKind elementTypeKind = element.asType().getKind(); String elementName = element.getSimpleName().toString(); String elementNameLowerCase = elementName.toLowerCase(); List<? extends Element> elementMembers = elements.getAllMembers(enclosingElement); List<ExecutableElement> elementMethods = ElementFilter.methodsIn(elementMembers); for (ExecutableElement methodElement : elementMethods) { if (methodElement.getParameters().size() == 0) { String methodNameString = methodElement.getSimpleName().toString(); String methodNameLowerCase = methodNameString.toLowerCase(); if (methodElement.getParameters().size() == 0) { if (methodElement.getReturnType().toString().equals(element.asType().toString())) { return methodNameString;
Types types = processingEnv.getTypeUtils(); Elements elements = processingEnv.getElementUtils(); if (entity.element().getKind() == ElementKind.INTERFACE) { Queue<TypeMirror> interfaces = new LinkedList<>(entity.element().getInterfaces()); while (!interfaces.isEmpty()) { TypeMirror mirror = interfaces.remove(); TypeElement superElement = elements.getTypeElement(mirror.toString()); if (superElement != null) { mergeSuperType(entity, superElement); interfaces.addAll(superElement.getInterfaces()); TypeMirror typeMirror = entity.element().getSuperclass(); while (typeMirror.getKind() != TypeKind.NONE) { TypeElement superElement = elements.getTypeElement(typeMirror.toString()); if (superElement != null) { mergeSuperType(entity, superElement); StringBuilder sb = new StringBuilder("Model has error(s) code generation may fail: "); validators.forEach(validator -> sb.append(validator.toString())); processingEnv.getMessager().printMessage(Diagnostic.Kind.WARNING, sb);
private boolean isSubtype(Element typeElement, String type) { return processingEnv.getTypeUtils().isSubtype(typeElement.asType(), processingEnv.getElementUtils().getTypeElement(type).asType()); }
Element element = delegateMethod.getEnclosingElement(); String name = method.getSimpleName().toString(); Type delegateType = typeFactory.getType(element.asType(), true); Type returnType = typeFactory.getType(method.getReturnType(), true); List<Parameter> parameters = elementHandler.transformParams(method.getParameters()); for (AnnotationMirror annotation : delegateMethod.getAnnotationMirrors()) { if (TypeUtils.isAnnotationMirrorOfType(annotation, QueryDelegate.class)) { TypeMirror type = TypeUtils.getAnnotationValueAsTypeMirror(annotation, "value"); registerTypeElement(entityType.getFullName(), (TypeElement) element); entityType.addDelegate(new Delegate(entityType, delegateType, name, parameters, returnType)); TypeElement typeElement = processingEnv.getElementUtils().getTypeElement(entityType.getFullName()); boolean isAnnotated = false; for (Class<? extends Annotation> ann : conf.getEntityAnnotations()) { if (typeElement.getAnnotation(ann) != null) { isAnnotated = true; typeElements.add(processingEnv.getElementUtils().getTypeElement(entityType.getFullName())); } else {
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 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 writeAsyncClass(Element elem) throws ClassNotFoundException, IOException, Exception { if (elem.getKind().isInterface()) { TypeElement interfaceClazz = (TypeElement) elem; String className = interfaceClazz.getSimpleName().toString(); TypeSpec.Builder classBuilder = TypeSpec.interfaceBuilder(className + ASYNC).addModifiers(Modifier.PUBLIC) .addSuperinterface(TypeName.get(elem.asType())); // add class generic type classBuilder.addTypeVariables(getTypeNames(interfaceClazz.getTypeParameters())); // add direct method addMethods(interfaceClazz, classBuilder); // add method form superinterface addSuperInterfaceMethods(interfaceClazz.getInterfaces(), classBuilder); // write class JavaFile javaFile = JavaFile.builder(processingEnv.getElementUtils().getPackageOf(interfaceClazz).getQualifiedName().toString(), classBuilder.build()).build(); javaFile.writeTo(new File(System.getProperty("basedir"), TARGET_DIR)); } else { processingEnv.getMessager().printMessage(Diagnostic.Kind.NOTE, "MotanAsyncProcessor not process, because " + elem.toString() + " not a interface."); } }
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(
@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(); }