}

        public <A extends Annotation> A getAnnotation(Class<A> type) {
            A methodAnnotation = featureMethod.getAnnotation(type);
            if (methodAnnotation != null) {
                return methodAnnotation;
            }
            return spec.getAnnotation(type);
        }

        public Annotation[] getAnnotations() {

    }

    private static String getCallableName(ExecutableElement methodElement, CallableKindInfo kindInfo) {
        CallableDefinition.Name nameAnnotation = methodElement.getAnnotation(CallableDefinition.Name.class);
        String nameFromPattern = callableNameFromNamingConvention(methodElement.getSimpleName().toString());
        if (kindInfo == CallableKindInfo.AFTER_CONSTRUCTOR) {

        propertyMetadata.getAnnotation(SoftwareType.class).ifPresent(softwareType ->
            visitor.visitSoftwareTypeProperty(propertyName, value, softwareType)
        );
    }

    @Override
    public void validatePropertyMetadata(PropertyMetadata propertyMetadata, TypeValidationContext validationContext) {
        propertyMetadata.getAnnotation(SoftwareType.class).ifPresent(softwareType -> {

    def versions
    def coverage

    MultiVersionTestInterceptor(Class<?> target) {
        super(target)
        versions = target.getAnnotation(TargetVersions)
        coverage = target.getAnnotation(TargetCoverage)
    }

    @Override
    protected Collection<DefaultVersionedTool> getAllVersions() {
        if (versions != null) {

                if (methodDesc != null) {
                    final Method method = methodDesc.getMethod();
                    final PreDestroy postConstruct = method.getAnnotation(PreDestroy.class);
                    if (postConstruct != null) {
                        MethodUtil.invoke(method, instance);
                    }
                }
            }

                        }

                        @Nullable
                        @Override
                        public <S extends Annotation> S getAnnotation(Class<S> annotation) {
                            return constructor.getAnnotation(annotation);
                        }

                        @Override
                        public int getModifiers() {

                // If there is a single constructor, and that constructor is public or package private we select it.
                return constructor;
            }
            if (constructor.getAnnotation(Inject.class) != null) {
                // Otherwise, if there is a single constructor that is annotated with `@Inject`, we select it (short-circuit).
                return constructor;
            }
        }

    return declaration;
  }

  @Override
  public boolean isAnnotationPresent(Class<? extends Annotation> annotationType) {
    return getAnnotation(annotationType) != null;
  }

  @Override
  @CheckForNull
  public <A extends Annotation> A getAnnotation(Class<A> annotationType) {
    checkNotNull(annotationType);
    for (Annotation annotation : annotations) {
      if (annotationType.isInstance(annotation)) {

            if (constructor.getParameterTypes().length == 0 && isPublicOrPackageScoped(type.getGeneratedClass(), constructor)) {
                return constructor;
            }
            if (constructor.getAnnotation(Inject.class) != null) {
                return constructor;
            }
            if (constructor.getParameterTypes().length == 0) {
                TreeFormatter formatter = new TreeFormatter();

        Closure ignoreVersions = getAnnotationClosure(target, IgnoreVersions, {})
        if (ignoreVersions(previousVersion)) {
            return false
        }

        def versionsAnnotation = target.getAnnotation(TargetVersions)
        if (versionsAnnotation == null) {
            return true
        }

        List<String> targetGradleVersions = versionsAnnotation.value()