docs: protected Map<CharSequence, Object> populateAnnotationData(
              T originatingElement,
              A annotationMirror,
              DefaultAnnotationMetadata metadata,
              boolean isDeclared) {
          String annotationName = getAnnotationTypeName(annotationMirror);
  
          processAnnotationDefaults(originatingElement, annotationMirror, metadata, annotationName);
  
          List<String> parentAnnotations = new ArrayList<>();
          parentAnnotations.add(annotationName);
          Map<? extends T, ?> elementValues = readAnnotationRawValues(annotationMirror);
          Map<CharSequence, Object> annotationValues;
          if (CollectionUtils.isEmpty(elementValues)) {
              annotationValues = Collections.emptyMap();
          } else {
              annotationValues = new LinkedHashMap<>();
              for (Map.Entry<? extends T, ?> entry : elementValues.entrySet()) {
                  T member = entry.getKey();
  
                  if (member == null) {
                      continue;
                  }
  
                  boolean isInstantiatedMember = hasAnnotation(member, InstantiatedMember.class);
                  Optional<?> aliases = getAnnotationValues(originatingElement, member, Aliases.class).get("value");
                  Object annotationValue = entry.getValue();
                  if (isInstantiatedMember) {
                      final String memberName = getAnnotationMemberName(member);
                      final Object rawValue = readAnnotationValue(originatingElement, memberName, annotationValue);
                      if (rawValue instanceof AnnotationClassValue) {
                          AnnotationClassValue acv = (AnnotationClassValue) rawValue;
                          annotationValues.put(memberName, new AnnotationClassValue(acv.getName(), true));
                      }
                  } else {
                      if (aliases.isPresent()) {
                          Object value = aliases.get();
                          if (value instanceof io.micronaut.core.annotation.AnnotationValue[]) {
                              io.micronaut.core.annotation.AnnotationValue[] values = (io.micronaut.core.annotation.AnnotationValue[]) value;
                              for (io.micronaut.core.annotation.AnnotationValue av : values) {
                                  OptionalValues<Object> aliasForValues = OptionalValues.of(Object.class, av.getValues());
                                  processAnnotationAlias(
                                          originatingElement,
                                          annotationName,
                                          member, metadata,
                                          isDeclared,
                                          parentAnnotations,
                                          annotationValues,
                                          annotationValue,
                                          aliasForValues
                                  );
                              }
                          }
                          readAnnotationRawValues(originatingElement, annotationName, member, getAnnotationMemberName(member), annotationValue, annotationValues);
                      } else {
                          OptionalValues<?> aliasForValues = getAnnotationValues(
                                  originatingElement,
                                  member,
                                  AliasFor.class
                          );
                          processAnnotationAlias(
                                  originatingElement,
                                  annotationName,
                                  member,
                                  metadata,
                                  isDeclared,
                                  parentAnnotations,
                                  annotationValues,
                                  annotationValue,
                                  aliasForValues
                          );
                          readAnnotationRawValues(originatingElement, annotationName, member, getAnnotationMemberName(member), annotationValue, annotationValues);
                      }
                  }
  
              }
          }
          List<AnnotationMapper> mappers = ANNOTATION_MAPPERS.get(annotationName);
          if (mappers != null) {
              AnnotationValue<?> annotationValue = new AnnotationValue(annotationName, annotationValues);
              VisitorContext visitorContext = createVisitorContext();
              for (AnnotationMapper mapper : mappers) {
                  List mapped = mapper.map(annotationValue, visitorContext);
                  if (mapped != null) {
                      for (Object o : mapped) {
                          if (o instanceof AnnotationValue) {
                              AnnotationValue av = (AnnotationValue) o;
                              String mappedAnnotationName = av.getAnnotationName();
  
                              Optional<T> mappedMirror = getAnnotationMirror(mappedAnnotationName);
                              String repeatableName = mappedMirror.map(this::getRepeatableNameForType).orElse(null);
                              if (repeatableName != null) {
                                  if (isDeclared) {
                                      metadata.addDeclaredRepeatable(
                                              repeatableName,
                                              av
                                      );
                                  } else {
                                      metadata.addRepeatable(
                                              repeatableName,
                                              av
                                      );
                                  }
                              } else {
                                  if (isDeclared) {
                                      metadata.addDeclaredAnnotation(
                                              mappedAnnotationName,
                                              av.getValues()
                                      );
                                  } else {
                                      metadata.addAnnotation(
                                              mappedAnnotationName,
                                              av.getValues()
                                      );
                                  }
                              }
  
                              mappedMirror.ifPresent(annMirror -> {
                                  final Map<? extends T, ?> defaultValues = readAnnotationDefaultValues(mappedAnnotationName, annMirror);
                                  processAnnotationDefaults(originatingElement, metadata, mappedAnnotationName, defaultValues);
                                  final ArrayList<String> parents = new ArrayList<>();
                                  processAnnotationStereotype(
                                          parents,
                                          annMirror,
                                          mappedAnnotationName,
                                          metadata,
                                          isDeclared);
  
                              });
                          }
                      }
                  }
              }
          }
          return annotationValues;
      }