Search in sources :

Example 1 with JavaVisitorContext

use of io.micronaut.annotation.processing.visitor.JavaVisitorContext in project micronaut-kubernetes by micronaut-projects.

the class KubernetesApisProcessor method writeReactorClients.

private void writeReactorClients(Element e, String packageName, String simpleName) {
    final String reactorClientName = simpleName + "ReactorClient";
    final String reactorPackageName = packageName.replace(KUBERNETES_APIS_PACKAGE, MICRONAUT_APIS_PACKAGE + ".reactor");
    ClassName cn = ClassName.get(reactorPackageName, reactorClientName);
    TypeSpec.Builder builder = TypeSpec.classBuilder(cn);
    ClassName clientType = ClassName.get(packageName, simpleName);
    ClassName reactorMonoType = ClassName.get("reactor.core.publisher", "Mono");
    final AnnotationSpec.Builder requiresSpec = AnnotationSpec.builder(Requires.class).addMember("beans", "{$T.class}", clientType);
    builder.addAnnotation(requiresSpec.build());
    builder.addAnnotation(Singleton.class);
    if (Objects.equals(simpleName, "CoreV1Api")) {
        builder.addAnnotation(BootstrapContextCompatible.class);
    }
    builder.addModifiers(Modifier.PUBLIC);
    builder.addField(clientType, "client", Modifier.FINAL, Modifier.PRIVATE);
    builder.addMethod(MethodSpec.constructorBuilder().addParameter(clientType, "client").addCode("this.client = client;").build());
    TypeElement typeElement = elements.getTypeElement(clientType.reflectionName());
    if (typeElement != null) {
        ModelUtils modelUtils = new ModelUtils(elements, types) {
        };
        GenericUtils genericUtils = new GenericUtils(elements, types, modelUtils) {
        };
        AnnotationUtils annotationUtils = new AnnotationUtils(processingEnv, elements, messager, types, modelUtils, genericUtils, filer) {
        };
        JavaVisitorContext visitorContext = new JavaVisitorContext(processingEnv, messager, elements, annotationUtils, types, modelUtils, genericUtils, filer, MutableConvertibleValues.of(new LinkedHashMap<>()), TypeElementVisitor.VisitorKind.ISOLATING);
        typeElement.asType().accept(new PublicMethodVisitor<Object, Object>(visitorContext) {

            @Override
            protected void accept(DeclaredType type, Element element, Object o) {
                ExecutableElement ee = (ExecutableElement) element;
                TypeMirror returnType = ee.getReturnType();
                if (element.getSimpleName().toString().endsWith("Async")) {
                    DeclaredType dt = (DeclaredType) returnType;
                    Element e = dt.asElement();
                    if (e.getSimpleName().toString().equals("Call")) {
                        List<? extends VariableElement> parameters = ee.getParameters();
                        VariableElement fieldElement = parameters.get(parameters.size() - 1);
                        TypeMirror typeMirror = fieldElement.asType();
                        if (typeMirror instanceof DeclaredType) {
                            DeclaredType cdt = (DeclaredType) typeMirror;
                            List<? extends TypeMirror> typeArguments = cdt.getTypeArguments();
                            if (typeArguments.size() == 1) {
                                TypeMirror ctm = typeArguments.get(0);
                                if (ctm instanceof DeclaredType) {
                                    // resolve the callback response type
                                    TypeName responseType = ClassName.get(ctm);
                                    // resolve the method name by removing the Async suffix
                                    String methodName = ee.getSimpleName().toString();
                                    String finalMethodName = methodName.replace("Async", "");
                                    // prepare parameters for the method without tha _callback one
                                    List<ParameterSpec> parameterSpecs = parameters.stream().filter(va -> !va.getSimpleName().toString().equals("_callback")).filter(va -> !va.getSimpleName().toString().equals("watch")).map(va -> ParameterSpec.builder(ClassName.get(va.asType()), va.getSimpleName().toString()).build()).collect(Collectors.toList());
                                    MethodSpec.Builder methodBuilder = MethodSpec.methodBuilder(finalMethodName).addModifiers(Modifier.PUBLIC).addParameters(parameterSpecs).returns(ParameterizedTypeName.get(reactorMonoType, responseType));
                                    methodBuilder.addCode(CodeBlock.builder().addStatement("return $T.create((sink) -> {", reactorMonoType).addStatement("try {").add("    this.client." + methodName + "(").add(parameters.stream().map(va -> {
                                        String name = va.getSimpleName().toString();
                                        if (name.equals("_callback")) {
                                            return "new AsyncCallbackSink<" + responseType + ">(sink)";
                                        } else if (name.equals("watch")) {
                                            return "Boolean.FALSE";
                                        } else {
                                            return name;
                                        }
                                    }).collect(Collectors.joining(", "))).addStatement(")").addStatement("} catch(io.kubernetes.client.openapi.ApiException e) { sink.error(e); }").addStatement("})").build());
                                    builder.addMethod(methodBuilder.build());
                                }
                            }
                        }
                    }
                }
            }
        }, null);
    }
    writeJavaFile(e, reactorPackageName, cn, builder);
}
Also used : com.squareup.javapoet(com.squareup.javapoet) AnnotationUtils(io.micronaut.annotation.processing.AnnotationUtils) GenericUtils(io.micronaut.annotation.processing.GenericUtils) Elements(javax.lang.model.util.Elements) ArrayList(java.util.ArrayList) javax.annotation.processing(javax.annotation.processing) LinkedHashMap(java.util.LinkedHashMap) PublicMethodVisitor(io.micronaut.annotation.processing.PublicMethodVisitor) TypeElementVisitor(io.micronaut.inject.visitor.TypeElementVisitor) JavaVisitorContext(io.micronaut.annotation.processing.visitor.JavaVisitorContext) BootstrapContextCompatible(io.micronaut.context.annotation.BootstrapContextCompatible) Diagnostic(javax.tools.Diagnostic) DeclaredType(javax.lang.model.type.DeclaredType) Map(java.util.Map) Requires(io.micronaut.context.annotation.Requires) MutableConvertibleValues(io.micronaut.core.convert.value.MutableConvertibleValues) NameUtils(io.micronaut.core.naming.NameUtils) javax.lang.model.element(javax.lang.model.element) Singleton(jakarta.inject.Singleton) Set(java.util.Set) IOException(java.io.IOException) Types(javax.lang.model.util.Types) Collectors(java.util.stream.Collectors) JavaFileObject(javax.tools.JavaFileObject) Objects(java.util.Objects) SourceVersion(javax.lang.model.SourceVersion) TypeMirror(javax.lang.model.type.TypeMirror) List(java.util.List) Factory(io.micronaut.context.annotation.Factory) ModelUtils(io.micronaut.annotation.processing.ModelUtils) Writer(java.io.Writer) LinkedHashMap(java.util.LinkedHashMap) ModelUtils(io.micronaut.annotation.processing.ModelUtils) TypeMirror(javax.lang.model.type.TypeMirror) ArrayList(java.util.ArrayList) List(java.util.List) Requires(io.micronaut.context.annotation.Requires) JavaVisitorContext(io.micronaut.annotation.processing.visitor.JavaVisitorContext) GenericUtils(io.micronaut.annotation.processing.GenericUtils) AnnotationUtils(io.micronaut.annotation.processing.AnnotationUtils) JavaFileObject(javax.tools.JavaFileObject) DeclaredType(javax.lang.model.type.DeclaredType)

Example 2 with JavaVisitorContext

use of io.micronaut.annotation.processing.visitor.JavaVisitorContext in project odi by eclipse-ee4j.

the class AnnotatedConstructAnnotationTarget method asClassElement.

private ClassElement asClassElement(DeclaredType declaredType) {
    javax.lang.model.element.Element annotationElement = declaredType.asElement();
    JavaVisitorContext javaVisitorContext = visitorContext;
    ClassElement classElement = javaVisitorContext.getElementFactory().newClassElement((TypeElement) declaredType.asElement(), visitorContext.getAnnotationUtils().getAnnotationMetadata(annotationElement));
    return classElement;
}
Also used : JavaVisitorContext(io.micronaut.annotation.processing.visitor.JavaVisitorContext) ClassElement(io.micronaut.inject.ast.ClassElement)

Example 3 with JavaVisitorContext

use of io.micronaut.annotation.processing.visitor.JavaVisitorContext in project micronaut-core by micronaut-projects.

the class BeanDefinitionInjectProcessor method process.

@Override
public final boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
    processingOver = roundEnv.processingOver();
    if (!processingOver) {
        annotations = annotations.stream().filter(ann -> {
            final String name = ann.getQualifiedName().toString();
            String packageName = NameUtils.getPackageName(name);
            return !name.equals(AnnotationUtil.KOTLIN_METADATA) && !AnnotationUtil.STEREOTYPE_EXCLUDES.contains(packageName);
        }).filter(ann -> annotationUtils.hasStereotype(ann, ANNOTATION_STEREOTYPES) || isProcessedAnnotation(ann.getQualifiedName().toString())).collect(Collectors.toSet());
        if (!annotations.isEmpty()) {
            TypeElement groovyObjectTypeElement = elementUtils.getTypeElement("groovy.lang.GroovyObject");
            TypeMirror groovyObjectType = groovyObjectTypeElement != null ? groovyObjectTypeElement.asType() : null;
            // accumulate all the class elements for all annotated elements
            annotations.forEach(annotation -> roundEnv.getElementsAnnotatedWith(annotation).stream().filter(element -> element.getKind() != ANNOTATION_TYPE).forEach(element -> {
                TypeElement typeElement = modelUtils.classElementFor(element);
                if (typeElement == null) {
                    return;
                }
                if (element.getKind() == ENUM) {
                    final AnnotationMetadata am = annotationUtils.getAnnotationMetadata(element);
                    if (isDeclaredBeanInMetadata(am)) {
                        error(element, "Enum types cannot be defined as beans");
                    }
                    return;
                }
                // skip Groovy code, handled by InjectTransform. Required for GroovyEclipse compiler
                if ((groovyObjectType != null && typeUtils.isAssignable(typeElement.asType(), groovyObjectType))) {
                    return;
                }
                String name = typeElement.getQualifiedName().toString();
                if (!beanDefinitions.contains(name) && !processed.contains(name) && !name.endsWith(BeanDefinitionVisitor.PROXY_SUFFIX)) {
                    boolean isInterface = JavaModelUtils.resolveKind(typeElement, ElementKind.INTERFACE).isPresent();
                    if (!isInterface) {
                        beanDefinitions.add(name);
                    } else {
                        if (annotationUtils.hasStereotype(typeElement, INTRODUCTION_TYPE) || annotationUtils.hasStereotype(typeElement, ConfigurationReader.class)) {
                            beanDefinitions.add(name);
                        }
                    }
                }
            }));
        }
        // remove already processed in previous round
        for (String name : processed) {
            beanDefinitions.remove(name);
        }
        // process remaining
        int count = beanDefinitions.size();
        if (count > 0) {
            note("Creating bean classes for %s type elements", count);
            beanDefinitions.forEach(className -> {
                if (processed.add(className)) {
                    final TypeElement refreshedClassElement = elementUtils.getTypeElement(className);
                    try {
                        final AnnBeanElementVisitor visitor = new AnnBeanElementVisitor(refreshedClassElement);
                        refreshedClassElement.accept(visitor, className);
                        visitor.getBeanDefinitionWriters().forEach((name, writer) -> {
                            String beanDefinitionName = writer.getBeanDefinitionName();
                            if (processed.add(beanDefinitionName)) {
                                processBeanDefinitions(writer);
                            }
                        });
                        AnnotationUtils.invalidateMetadata(refreshedClassElement);
                    } catch (PostponeToNextRoundException e) {
                        processed.remove(className);
                    }
                }
            });
            AnnotationUtils.invalidateCache();
        }
    }
    /*
        Since the underlying Filer expects us to write only once into a file we need to make sure it happens in the last
        processing round.
        */
    if (processingOver) {
        try {
            writeBeanDefinitionsToMetaInf();
            for (BeanElementVisitor<?> visitor : BeanElementVisitor.VISITORS) {
                if (visitor.isEnabled()) {
                    try {
                        visitor.finish(javaVisitorContext);
                    } catch (Exception e) {
                        javaVisitorContext.fail("Error finalizing bean element visitor [" + visitor.getClass().getName() + "]: " + e.getMessage(), null);
                    }
                }
            }
            final List<AbstractBeanDefinitionBuilder> beanElementBuilders = javaVisitorContext.getBeanElementBuilders();
            if (CollectionUtils.isNotEmpty(beanElementBuilders)) {
                try {
                    AbstractBeanDefinitionBuilder.writeBeanDefinitionBuilders(classWriterOutputVisitor, beanElementBuilders);
                } catch (IOException e) {
                    // raise a compile error
                    String message = e.getMessage();
                    error("Unexpected error: %s", message != null ? message : e.getClass().getSimpleName());
                }
            }
        } finally {
            AnnotationUtils.invalidateCache();
            AbstractAnnotationMetadataBuilder.clearMutated();
            JavaAnnotationMetadataBuilder.clearCaches();
        }
    }
    return false;
}
Also used : InterceptorBinding(io.micronaut.aop.InterceptorBinding) Bindable(io.micronaut.core.bind.annotation.Bindable) Arrays(java.util.Arrays) SupportedOptions(javax.annotation.processing.SupportedOptions) Modifier(javax.lang.model.element.Modifier) TypeElement(javax.lang.model.element.TypeElement) Internal(io.micronaut.core.annotation.Internal) Introduction(io.micronaut.aop.Introduction) Duration(java.time.Duration) Map(java.util.Map) PropertyMetadata(io.micronaut.inject.configuration.PropertyMetadata) AnnotationClassValue(io.micronaut.core.annotation.AnnotationClassValue) Property(io.micronaut.context.annotation.Property) AnnotationMetadataHierarchy(io.micronaut.inject.annotation.AnnotationMetadataHierarchy) Set(java.util.Set) Element(javax.lang.model.element.Element) Bean(io.micronaut.context.annotation.Bean) Interceptor(io.micronaut.aop.Interceptor) MethodElement(io.micronaut.inject.ast.MethodElement) AnnotationValue(javax.lang.model.element.AnnotationValue) EachProperty(io.micronaut.context.annotation.EachProperty) RequiresCondition(io.micronaut.context.RequiresCondition) MutableAnnotationMetadata(io.micronaut.inject.annotation.MutableAnnotationMetadata) ConfigurationMetadata(io.micronaut.inject.configuration.ConfigurationMetadata) JavaModelUtils(io.micronaut.inject.processing.JavaModelUtils) PackageElement(javax.lang.model.element.PackageElement) VariableElement(javax.lang.model.element.VariableElement) ParameterElement(io.micronaut.inject.ast.ParameterElement) LinkedHashMap(java.util.LinkedHashMap) TypedElement(io.micronaut.inject.ast.TypedElement) Nullable(io.micronaut.core.annotation.Nullable) DeclaredType(javax.lang.model.type.DeclaredType) ElementFilter(javax.lang.model.util.ElementFilter) LinkedHashSet(java.util.LinkedHashSet) InterceptedMethodUtil(io.micronaut.aop.internal.intercepted.InterceptedMethodUtil) IOException(java.io.IOException) OptionalValues(io.micronaut.core.value.OptionalValues) AnnotationMirror(javax.lang.model.element.AnnotationMirror) CONSTRUCTOR(javax.lang.model.element.ElementKind.CONSTRUCTOR) RoundEnvironment(javax.annotation.processing.RoundEnvironment) ElementQuery(io.micronaut.inject.ast.ElementQuery) BeanElementVisitor(io.micronaut.inject.visitor.BeanElementVisitor) ArrayUtils(io.micronaut.core.util.ArrayUtils) FieldElement(io.micronaut.inject.ast.FieldElement) ConfigurationInject(io.micronaut.context.annotation.ConfigurationInject) ENUM(javax.lang.model.element.ElementKind.ENUM) DefaultScope(io.micronaut.context.annotation.DefaultScope) JavaVisitorContext(io.micronaut.annotation.processing.visitor.JavaVisitorContext) AtomicInteger(java.util.concurrent.atomic.AtomicInteger) ConfigurationBuilder(io.micronaut.context.annotation.ConfigurationBuilder) NameUtils(io.micronaut.core.naming.NameUtils) JavaMethodElement(io.micronaut.annotation.processing.visitor.JavaMethodElement) Executable(io.micronaut.context.annotation.Executable) Context(io.micronaut.context.annotation.Context) Predicate(java.util.function.Predicate) AccessorsStyle(io.micronaut.core.annotation.AccessorsStyle) Collectors(java.util.stream.Collectors) TypeKind(javax.lang.model.type.TypeKind) Objects(java.util.Objects) StringUtils(io.micronaut.core.util.StringUtils) ElementScanner8(javax.lang.model.util.ElementScanner8) List(java.util.List) Factory(io.micronaut.context.annotation.Factory) AnnotationUtil(io.micronaut.core.annotation.AnnotationUtil) JavaElementFactory(io.micronaut.annotation.processing.visitor.JavaElementFactory) TypeVariable(javax.lang.model.type.TypeVariable) Optional(java.util.Optional) AbstractBeanDefinitionBuilder(io.micronaut.inject.writer.AbstractBeanDefinitionBuilder) BeanDefinitionWriter(io.micronaut.inject.writer.BeanDefinitionWriter) OriginatingElements(io.micronaut.inject.writer.OriginatingElements) ClassElement(io.micronaut.inject.ast.ClassElement) Adapter(io.micronaut.aop.Adapter) HashSet(java.util.HashSet) ANNOTATION_TYPE(javax.lang.model.element.ElementKind.ANNOTATION_TYPE) AnnotationMetadataReference(io.micronaut.inject.annotation.AnnotationMetadataReference) Requires(io.micronaut.context.annotation.Requires) ConfigurationReader(io.micronaut.context.annotation.ConfigurationReader) AbstractAnnotationMetadataBuilder(io.micronaut.inject.annotation.AbstractAnnotationMetadataBuilder) Name(javax.lang.model.element.Name) BeanDefinitionReferenceWriter(io.micronaut.inject.writer.BeanDefinitionReferenceWriter) VisitorConfiguration(io.micronaut.inject.visitor.VisitorConfiguration) ElementKind(javax.lang.model.element.ElementKind) ExecutableElement(javax.lang.model.element.ExecutableElement) FIELD(javax.lang.model.element.ElementKind.FIELD) Value(io.micronaut.context.annotation.Value) TypeParameterElement(javax.lang.model.element.TypeParameterElement) InterceptorKind(io.micronaut.aop.InterceptorKind) TimeUnit(java.util.concurrent.TimeUnit) NonNull(io.micronaut.core.annotation.NonNull) TypeMirror(javax.lang.model.type.TypeMirror) CollectionUtils(io.micronaut.core.util.CollectionUtils) AopProxyWriter(io.micronaut.aop.writer.AopProxyWriter) ConfigurationMetadataBuilder(io.micronaut.inject.configuration.ConfigurationMetadataBuilder) BeanDefinitionVisitor(io.micronaut.inject.writer.BeanDefinitionVisitor) ProcessingEnvironment(javax.annotation.processing.ProcessingEnvironment) PrimitiveType(javax.lang.model.type.PrimitiveType) AnnotationMetadata(io.micronaut.core.annotation.AnnotationMetadata) Collections(java.util.Collections) TypeElement(javax.lang.model.element.TypeElement) AbstractBeanDefinitionBuilder(io.micronaut.inject.writer.AbstractBeanDefinitionBuilder) IOException(java.io.IOException) MutableAnnotationMetadata(io.micronaut.inject.annotation.MutableAnnotationMetadata) AnnotationMetadata(io.micronaut.core.annotation.AnnotationMetadata) IOException(java.io.IOException) TypeMirror(javax.lang.model.type.TypeMirror)

Example 4 with JavaVisitorContext

use of io.micronaut.annotation.processing.visitor.JavaVisitorContext in project micronaut-kubernetes by micronaut-projects.

the class KubernetesApisProcessor method writeRxJavaClients.

private void writeRxJavaClients(Element e, String packageName, String simpleName, String rxVersionSuffix, String rxJavaPackage) {
    final String rx = simpleName + "RxClient";
    final String rxPackageName = packageName.replace(KUBERNETES_APIS_PACKAGE, MICRONAUT_APIS_PACKAGE + rxVersionSuffix);
    ClassName cn = ClassName.get(rxPackageName, rx);
    TypeSpec.Builder builder = TypeSpec.classBuilder(cn);
    ClassName clientType = ClassName.get(packageName, simpleName);
    ClassName rxSingleType = ClassName.get(rxJavaPackage, "Single");
    final AnnotationSpec.Builder requiresSpec = AnnotationSpec.builder(Requires.class).addMember("beans", "{$T.class}", clientType);
    builder.addAnnotation(requiresSpec.build());
    builder.addAnnotation(Singleton.class);
    builder.addModifiers(Modifier.PUBLIC);
    builder.addField(clientType, "client", Modifier.FINAL, Modifier.PRIVATE);
    builder.addMethod(MethodSpec.constructorBuilder().addParameter(clientType, "client").addCode("this.client = client;").build());
    TypeElement typeElement = elements.getTypeElement(clientType.reflectionName());
    if (typeElement != null) {
        ModelUtils modelUtils = new ModelUtils(elements, types) {
        };
        GenericUtils genericUtils = new GenericUtils(elements, types, modelUtils) {
        };
        AnnotationUtils annotationUtils = new AnnotationUtils(processingEnv, elements, messager, types, modelUtils, genericUtils, filer) {
        };
        JavaVisitorContext visitorContext = new JavaVisitorContext(processingEnv, messager, elements, annotationUtils, types, modelUtils, genericUtils, filer, MutableConvertibleValues.of(new LinkedHashMap<>()), TypeElementVisitor.VisitorKind.ISOLATING);
        typeElement.asType().accept(new PublicMethodVisitor<Object, Object>(visitorContext) {

            @Override
            protected void accept(DeclaredType type, Element element, Object o) {
                ExecutableElement ee = (ExecutableElement) element;
                TypeMirror returnType = ee.getReturnType();
                if (element.getSimpleName().toString().endsWith("Async")) {
                    DeclaredType dt = (DeclaredType) returnType;
                    Element e = dt.asElement();
                    if (e.getSimpleName().toString().equals("Call")) {
                        List<? extends VariableElement> parameters = ee.getParameters();
                        VariableElement fieldElement = parameters.get(parameters.size() - 1);
                        TypeMirror typeMirror = fieldElement.asType();
                        if (typeMirror instanceof DeclaredType) {
                            DeclaredType cdt = (DeclaredType) typeMirror;
                            List<? extends TypeMirror> typeArguments = cdt.getTypeArguments();
                            if (typeArguments.size() == 1) {
                                TypeMirror ctm = typeArguments.get(0);
                                if (ctm instanceof DeclaredType) {
                                    // resolve the callback response type
                                    TypeName responseType = ClassName.get(ctm);
                                    // resolve the method name by removing the Async suffix
                                    String methodName = ee.getSimpleName().toString();
                                    String finalMethodName = methodName.replace("Async", "");
                                    // prepare parameters for the method without tha _callback one
                                    List<ParameterSpec> parameterSpecs = parameters.stream().filter(va -> !va.getSimpleName().toString().equals("_callback")).filter(va -> !va.getSimpleName().toString().equals("watch")).map(va -> ParameterSpec.builder(ClassName.get(va.asType()), va.getSimpleName().toString()).build()).collect(Collectors.toList());
                                    MethodSpec.Builder methodBuilder = MethodSpec.methodBuilder(finalMethodName).addModifiers(Modifier.PUBLIC).addParameters(parameterSpecs).returns(ParameterizedTypeName.get(rxSingleType, responseType));
                                    methodBuilder.addCode(CodeBlock.builder().addStatement("return $T.create((emitter) -> {", rxSingleType).add("this.client." + methodName + "(").add(parameters.stream().map(va -> {
                                        String name = va.getSimpleName().toString();
                                        if (name.equals("_callback")) {
                                            return "new ApiCallbackEmitter<>(emitter)";
                                        } else if (name.equals("watch")) {
                                            return "Boolean.FALSE";
                                        } else {
                                            return name;
                                        }
                                    }).collect(Collectors.joining(", "))).addStatement(")").addStatement("})").build());
                                    builder.addMethod(methodBuilder.build());
                                }
                            }
                        }
                    }
                }
            }
        }, null);
    }
    writeJavaFile(e, rxPackageName, cn, builder);
}
Also used : com.squareup.javapoet(com.squareup.javapoet) AnnotationUtils(io.micronaut.annotation.processing.AnnotationUtils) GenericUtils(io.micronaut.annotation.processing.GenericUtils) Elements(javax.lang.model.util.Elements) ArrayList(java.util.ArrayList) javax.annotation.processing(javax.annotation.processing) LinkedHashMap(java.util.LinkedHashMap) PublicMethodVisitor(io.micronaut.annotation.processing.PublicMethodVisitor) TypeElementVisitor(io.micronaut.inject.visitor.TypeElementVisitor) JavaVisitorContext(io.micronaut.annotation.processing.visitor.JavaVisitorContext) BootstrapContextCompatible(io.micronaut.context.annotation.BootstrapContextCompatible) Diagnostic(javax.tools.Diagnostic) DeclaredType(javax.lang.model.type.DeclaredType) Map(java.util.Map) Requires(io.micronaut.context.annotation.Requires) MutableConvertibleValues(io.micronaut.core.convert.value.MutableConvertibleValues) NameUtils(io.micronaut.core.naming.NameUtils) javax.lang.model.element(javax.lang.model.element) Singleton(jakarta.inject.Singleton) Set(java.util.Set) IOException(java.io.IOException) Types(javax.lang.model.util.Types) Collectors(java.util.stream.Collectors) JavaFileObject(javax.tools.JavaFileObject) Objects(java.util.Objects) SourceVersion(javax.lang.model.SourceVersion) TypeMirror(javax.lang.model.type.TypeMirror) List(java.util.List) Factory(io.micronaut.context.annotation.Factory) ModelUtils(io.micronaut.annotation.processing.ModelUtils) Writer(java.io.Writer) LinkedHashMap(java.util.LinkedHashMap) ModelUtils(io.micronaut.annotation.processing.ModelUtils) TypeMirror(javax.lang.model.type.TypeMirror) ArrayList(java.util.ArrayList) List(java.util.List) Requires(io.micronaut.context.annotation.Requires) JavaVisitorContext(io.micronaut.annotation.processing.visitor.JavaVisitorContext) GenericUtils(io.micronaut.annotation.processing.GenericUtils) AnnotationUtils(io.micronaut.annotation.processing.AnnotationUtils) JavaFileObject(javax.tools.JavaFileObject) DeclaredType(javax.lang.model.type.DeclaredType)

Aggregations

JavaVisitorContext (io.micronaut.annotation.processing.visitor.JavaVisitorContext)4 Factory (io.micronaut.context.annotation.Factory)3 Requires (io.micronaut.context.annotation.Requires)3 NameUtils (io.micronaut.core.naming.NameUtils)3 IOException (java.io.IOException)3 LinkedHashMap (java.util.LinkedHashMap)3 List (java.util.List)3 Map (java.util.Map)3 Objects (java.util.Objects)3 Set (java.util.Set)3 Collectors (java.util.stream.Collectors)3 DeclaredType (javax.lang.model.type.DeclaredType)3 TypeMirror (javax.lang.model.type.TypeMirror)3 com.squareup.javapoet (com.squareup.javapoet)2 AnnotationUtils (io.micronaut.annotation.processing.AnnotationUtils)2 GenericUtils (io.micronaut.annotation.processing.GenericUtils)2 ModelUtils (io.micronaut.annotation.processing.ModelUtils)2 PublicMethodVisitor (io.micronaut.annotation.processing.PublicMethodVisitor)2 BootstrapContextCompatible (io.micronaut.context.annotation.BootstrapContextCompatible)2 JavaElementFactory (io.micronaut.annotation.processing.visitor.JavaElementFactory)1