}
    }

    public void disallowChangesAndFinalizeOnNextGet() {
        disallowChanges();
        finalizeOnNextGet();
    }

    public abstract boolean isExplicit();

    /**
     * Retrieves the current convention.
     */
    public abstract S convention();

    /**
     * Marks this value as being explicitly set with

        init(initialValue, initialValue);
    }

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

    protected boolean isExplicit() {
        return state.isExplicit();
    }

    @Override
    public boolean calculatePresence(ValueConsumer consumer) {
        try (EvaluationContext.ScopeContext context = openScope()) {

    }

    private Configurer getConfigurer() {
        return new Configurer();
    }

    @VisibleForTesting
    protected boolean isExplicit() {
        return valueState.isExplicit();
    }

    /**

        // Isolated projects also implies configuration cache
        if (startParameter.isolatedProjects.get() && !startParameter.configurationCache.get()) {
            if (startParameter.configurationCache.isExplicit) {
                throw GradleException("The configuration cache cannot be disabled when isolated projects is enabled.")
            }
        }

            includedBuildsByRootDir.put(buildDir, includedBuild);
            nestedBuildsByRootDir.put(buildDir, includedBuild);
            pendingIncludedBuilds.add(includedBuild);
            addBuild(includedBuild);
        } else {
            if (includedBuild.isImplicitBuild() != isImplicit) {

        return when (val explicitReceiver = qualifiedAccess.explicitReceiver) {
            is FirThisReceiverExpression -> {
                shortenOptions.removeThis &&
                        !explicitReceiver.isImplicit &&
                        explicitReceiver.calleeReference.referencesClosestReceiver()
            }

            is FirResolvedQualifier -> qualifiedAccess.extensionReceiver == null

                } else {
                    result
                }
            }
            this is FirThisReceiverExpression && this.isImplicit -> {
                val implicitPartiallyAppliedSymbol = when (val partiallyAppliedSymbol = calleeReference.boundSymbol) {
                    is FirClassSymbol<*> -> partiallyAppliedSymbol.toKtSymbol()