throw new IllegalStateException(getNullNestedCollectionValueExceptionMessage(qualifiedName));
            } else {
                TypeToken<?> getterType = propertyMetadata.getDeclaredType();
                TypeMetadata typeMetadata = getTypeMetadata(unpackType(getterType).getRawType());
                visitor.visitNested(typeMetadata, qualifiedName, propertyMetadata, null);
            }
        }

                PropertyValue cachedValue = new CachedPropertyValue(() -> propertyMetadata.getPropertyValue(parent), propertyMetadata.getDeclaredType().getRawType());
                PropertyAnnotationHandler handler = handlers.get(propertyMetadata.getPropertyType());
                if (handler == null) {

    }

    @Override
    public int compareTo(@Nonnull PropertyAnnotationMetadata o) {
        return propertyName.compareTo(o.getPropertyName());
    }

    @Override
    public TypeToken<?> getDeclaredType() {
        return declaredType;
    }

    @Nullable
    @Override
    public Object getPropertyValue(Object object) {
        try {
            return getter.invoke(object);

            });
        }

        private static Class<?> publicTypeOf(PropertyMetadata propertyMetadata, SoftwareType softwareType) {
            return softwareType.modelPublicType() == Void.class ? propertyMetadata.getDeclaredType().getRawType() : softwareType.modelPublicType();
        }
    }

    public String toString() {
        return delegate.toString();
    }

    private static String getPluginObjectDisplayName(Object parameterObject) {
        return ModelType.of(new DslObject(parameterObject).getDeclaredType()).getDisplayName();
    }

    private static Supplier<Optional<PluginId>> getOptionalSupplier(@Nullable String pluginId) {
        return () -> Optional.ofNullable(pluginId).map(DefaultPluginId::of);
    }

            pendingServices.clear();
            for (int i = 0; i < pendingRegistrations.size();) {
                Registration registration = pendingRegistrations.get(i);
                if (type.isAssignableFrom(registration.getDeclaredType())) {
                    addListener(registration.getInstance());
                    pendingRegistrations.remove(i);
                } else {
                    i++;
                }
            }

        return ServiceScope.class;
    }

    @Override
    public void whenRegistered(Class<? extends Annotation> annotation, Registration registration) {
        validateScope(registration.getDeclaredType());
    }

    private void validateScope(Class<?> serviceType) {
        if (ServiceScopeValidator.class.isAssignableFrom(serviceType)) {
            return;
        }

        validateUnsupportedInputPropertyValueTypes(propertyMetadata, validationContext, getAnnotationType());
        Class<?> valueType = propertyMetadata.getDeclaredType().getRawType();
        validateNotDirectoryType(propertyMetadata, validationContext, valueType);
        validateNotFileType(propertyMetadata, validationContext, valueType);

        return Cast.uncheckedCast(getInstantiator().newInstance(ExistingTaskProvider.class, this, object.getName(), new DslObject(object).getDeclaredType()));
    }

    @Override
    protected <I extends T> Action<? super I> withMutationDisabled(Action<? super I> action) {
        return parentMutationGuard.withMutationDisabled(super.withMutationDisabled(action));

        // When you call a method from Java with type arguments, in FIR they are currently represented as flexible types.
        // TODO Consider handling other non-ConeLookupTagBasedType types here (see KT-66418)
        val type = getDeclaredType()?.lowerBoundIfFlexible() as? ConeLookupTagBasedType

        return type?.toTargetSymbol(session, symbolBuilder) ?: run {
            val diagnostic = (this as? FirErrorTypeRef)?.diagnostic