import org.gradle.internal.service.scopes.ServiceRegistryFactory;
import org.gradle.internal.service.scopes.ServiceScope;

import java.io.Closeable;

/**
 * Controls the lifecycle of the mutable {@link ProjectInternal} instance for a project, plus its services.
 */
@ServiceScope(Scope.Project.class)
public class ProjectLifecycleController implements Closeable {
    private final ServiceRegistry buildServices;

}


private
suspend fun ReadContext.readAttributesUsing(
    attributesFactory: ImmutableAttributesFactory,
    managedFactories: ManagedFactoryRegistry
): AttributeContainerInternal =
    attributesFactory.mutable().apply {
        readCollection {
            val attribute = readAttribute()
            val value = readAttributeValue(managedFactories)
            attribute(attribute, value)
        }
    }


private

        this.projectLeaseRegistry = projectLeaseRegistry;
        this.globalContext = buildScopeServices::get;
    }

    /**
     * Create a calculated value that may have dependencies or that may need to access mutable model state.
     */
    public <T, S extends ValueCalculator<? extends T>> CalculatedValueContainer<T, S> create(DisplayName displayName, S supplier) {

                          TaskDependencyFactory taskDependencyFactory) {
        this.parentDisplayName = parentDisplayName;
        this.name = name;
        this.attributes = new FreezableAttributeContainer(cache.mutable(parentAttributes), parentDisplayName);
        this.artifactNotationParser = artifactNotationParser;

                problem
                    .forProperty(propertyName)
                    .id(TextUtil.screamingSnakeToKebabCase(MUTABLE_TYPE_WITH_SETTER), "Mutable type with setter", GradleCoreProblemGroup.validation().property())
                    .contextualLabel(String.format("of mutable type '%s' is writable", setterType.getName()))

import org.gradle.internal.Factory;
import org.gradle.internal.service.scopes.Scope;
import org.gradle.internal.service.scopes.ServiceScope;

/**
 * Allows a thread to enlist in resource locking, for example to lock the mutable state of a project.
 */
@ServiceScope(Scope.BuildSession.class)
public interface WorkerThreadRegistry {
    /**
     * Runs the given action as a worker. While the action is running, the thread can acquire resource locks.

        def extId = DefaultModuleComponentIdentifier.newId(DefaultModuleIdentifier.newId('group', 'external'), '1.0')
        def attributes = AttributeTestUtil.attributesFactory().mutable()
        attributes.attribute(Attribute.of('type', String), 'custom')
        attributes.attribute(Attribute.of('format', String), 'jar')
        def v1Result = Mock(ResolvedVariantResult)

    }

    /**
     * Creates a new non-finalized state.
     *
     * @param copier when the value is mutable, a shallow-copying function should be provided to avoid
     * sharing of mutable state between effective values and convention values
     */
    public static <S> ValueState<S> newState(PropertyHost host, Function<S, S> copier) {

        if (attributesFactory == null) {
            warnAboutInternalApiUse();
            return this;
        }
        validateMutation();
        if (attributes == null) {
            attributes = attributesFactory.mutable();
        }
        configureAction.execute(attributes);
        return this;
    }

    private void warnAboutInternalApiUse() {

    protected final Class<?> target;
    private final List<Execution> executions = new ArrayList<>();
    private final boolean runAllExecutions;

    private boolean executionsInitialized;

    // Yay, mutable state for storing the current execution.
    private Execution currentExecution;

    protected AbstractMultiTestInterceptor(Class<?> target) {
        this(target, true);
    }