return getPropertyValue(explicitLanguageLevel, new IdeaLanguageLevel(languageLevelConvention));
        }

        @Nullable
        private static <T> T takeIfDifferent(T commonValue, @Nullable T value) {
            return commonValue.equals(value) ? null : value;
        }

        @Nullable
        private static <T> T getPropertyValue(@Nullable T value, @Nullable T convention) {

    <T extends Annotation> Optional<T> getAnnotation(Class<T> annotationType);

    ImmutableMap<AnnotationCategory, Annotation> getAnnotations();

    TypeToken<?> getDeclaredType();

    @Nullable
    Object getPropertyValue(Object object);

            is ObjectOrigin.NullObjectOrigin -> null
            is ObjectOrigin.PropertyDefaultValue -> getPropertyValue(objectOrigin.receiver, objectOrigin.property)
            is ObjectOrigin.PropertyReference -> getPropertyValue(objectOrigin.receiver, objectOrigin.property)
            is ObjectOrigin.TopLevelReceiver -> topLevelObject

        property = new DefaultProperty<>(host, String.class);
        property.set(new TransformBackedProvider<>(String.class, new DefaultProvider<>(() -> value), v -> v + v));
    }

    @Benchmark
    public void getPropertyValue(Blackhole bh) {
        bh.consume(property.get());
    }

    boolean hasAnnotationForCategory(AnnotationCategory category);

    Class<? extends Annotation> getPropertyType();

    TypeToken<?> getDeclaredType();

    @Nullable
    Object getPropertyValue(Object object);

    }

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

    @Nullable
    @Override
    public Object getPropertyValue(Object object) {
        try {
            return getter.invoke(object);
        } catch (InvocationTargetException e) {
            throw UncheckedException.throwAsUncheckedException(e.getCause());

                            tokenizer.nextToken(MAPPED_END));
                    break;
                case PROPERTY_START:
                    propertyPosition = tokenizer.getPosition();
                    value = getPropertyValue(value, tokenizer.nextPropertyName());
                    break;
                default:
                    // could not parse expression
                    return null;
            }
        }

            return annotationMetadata.getDeclaredType();
        }

        @Nullable
        @Override
        public Object getPropertyValue(Object object) {
            return annotationMetadata.getPropertyValue(object);
        }

        @Override
        public String toString() {
            return String.format("@%s %s", propertyType.getSimpleName(), getPropertyName());

        return getter != null && getter.getMethod().isAnnotationPresent(annotationType);
    }

    public <I> T getPropertyValue(I instance) {
        return Cast.<WeaklyTypeReferencingMethod<I, T>>uncheckedCast(getGetter()).invoke(instance);
    }

    public WeaklyTypeReferencingMethod<?, ?> getGetter() {

        if (variantAspect != null) {
            for (ModelProperty<?> property : variantAspect.getDimensions()) {
                variants.put(property.getName(), property.getPropertyValue(binary));
            }
        }

        for (Map.Entry<String, Object> variant : variants.entrySet()) {
            String variantName = GUtil.toWords(variant.getKey());