/**
     * Sets a new convention value, replacing the existing one if set.
     *
     * @param convention the new convention value
     */
    public abstract void setConvention(S convention);

    public abstract void disallowChanges();

    public abstract void finalizeOnNextGet();

    public abstract void disallowUnsafeRead();

    /**

    public AbstractProperty(PropertyHost host) {
        state = ValueState.newState(host);
    }

    protected void init(S initialValue, S convention) {
        this.value = initialValue;
        this.state.setConvention(convention);
    }

    protected void init(S initialValue) {
        init(initialValue, initialValue);
    }

    @Override
    public boolean isFinalized() {
        return state.isFinalized();
    }

        if (value == null) {
            setConvention(noValueSupplier());
        } else {
            setConvention(new CollectingSupplier(new EntriesFromMap<>(value), false));
        }
        return this;
    }

    @Override
    public MapProperty<K, V> convention(Provider<? extends Map<? extends K, ? extends V>> valueProvider) {

        if (elements == null) {
            unsetConvention();
        } else {
            setConvention(new CollectingSupplier(new ElementsFromCollection<>(elements)));
        }
        return this;
    }

    @Override
    public HasMultipleValues<T> convention(Provider<? extends Iterable<? extends T>> provider) {
        setConvention(new CollectingSupplier(new ElementsFromCollectionProvider<>(Providers.internal(provider))));

        filesWrapper = new PathSet();
        buildDependency = dependencyFactory.configurableDependency();
    }

    private void init(ValueCollector initialValue, ValueCollector convention) {
        this.valueState.setConvention(convention);
        this.value = initialValue;
    }

    protected void withActualValue(Action<Configurer> action) {
        setToConventionIfUnset();
        action.execute(getConfigurer());
    }

        convention.getPlugins().put("bean", new ConventionBean());
        new ExtensibleDynamicObjectTestHelper().assertCanCallMethods(bean);
    }

    @Test
    public void canInvokeMethodsOnGroovyObjectFromGroovy() {
        GroovyBean bean = new GroovyBean();
        Convention convention = bean.extensibleDynamicObject.getConvention();

                // Reflective look up to still support plugins that inlined this function once conventions will be removed
                this::class.java.methods
                    .firstOrNull { it.name == "getConvention" }
                    ?.invoke(this)
                    ?.let { convention ->
                        convention::class.java
                            .getMethod("findPlugin", Class::class.java)

            }
        }
        return returnValue;
    }

    @Deprecated
    @Override
    public org.gradle.api.plugins.Convention getConvention() {
        DeprecationLogger.deprecateType(org.gradle.api.internal.HasConvention.class)
            .willBeRemovedInGradle9()
            .withUpgradeGuideSection(8, "deprecated_access_to_conventions")

        assertDynamicObject();
        if (disableDeprecationForConventionAccess) {
            return DeprecationLogger.whileDisabled(() -> extensibleDynamicObject.getConvention());
        }
        return extensibleDynamicObject.getConvention();
    }

    @Internal
    @Override
    public DynamicObject getAsDynamicObject() {
        assertDynamicObject();
        return extensibleDynamicObject;
    }

        DeprecationLogger.whileDisabled(() ->
            new DslObject(sourceSet).getConvention().getPlugins().put("groovy", groovySourceSet)
        );
        return groovySourceSet.getGroovy();
    }