* Services are visible to other services in the same scope and descendent scopes.
 * Services are not visible to services in ancestor scopes.
 * <p>
 * When a service is defined in multiple scopes, the highest scope determines the visibility.
 * The additional instances of the service in lower scopes "override" the instance from the parent
 * for their scope and its children.
 *
 * @see Scope
 */
@Retention(RetentionPolicy.RUNTIME)

import org.jetbrains.kotlin.analysis.api.fir.scopes.KaFirDelegatingNamesAwareScope
import org.jetbrains.kotlin.analysis.api.fir.scopes.KaFirDelegatingTypeScope
import org.jetbrains.kotlin.analysis.api.impl.base.scopes.KaCompositeScope
import org.jetbrains.kotlin.analysis.api.impl.base.scopes.KaCompositeTypeScope
import org.jetbrains.kotlin.analysis.api.scopes.KaScope
import org.jetbrains.kotlin.analysis.api.scopes.KaTypeScope

    private final Class<? extends Scope> scope;
    private final boolean strict;

    public ServiceScopeValidator(Class<? extends Scope> scope, boolean strict) {
        this.scope = scope;
        this.strict = strict;
    }

    @Override
    public List<Class<? extends Annotation>> getAnnotations() {

import org.gradle.internal.service.scopes.Scope
import org.gradle.internal.service.scopes.ServiceScope
import spock.lang.Specification

class ServiceRegistryBuilderTest extends Specification {

    def "creates a scope-validating service registry when setting a scope"() {
        def scopedBuilder = ServiceRegistryBuilder.builder()
            .scope(Scope.Build)

        when:
        scopedBuilder

     */
    public fun KaScopeContext.getCompositeScope(filter: (KaScopeKind) -> Boolean = { true }): KaScope = withValidityAssertion {
        val subScopes = scopes.filter { filter(it.kind) }.map { it.scope }
        subScopes.asCompositeScope()
    }
}

public typealias KtScopeProviderMixIn = KaScopeProviderMixIn

public class KaScopeContext(

        data = {}
        data["scopes"] = []
        for scope in form_data.scopes:
            data["scopes"].append(scope)
        if form_data.client_id:
            data["client_id"] = form_data.client_id
        if form_data.client_secret:
            data["client_secret"] = form_data.client_secret
        return data
    ```

    Note that for OAuth2 the scope `items:read` is a single scope in an opaque string.

    public Injector bindScope(Class<? extends Annotation> scopeAnnotation, Scope scope) {
        return bindScope(scopeAnnotation, () -> scope);
    }

    public Injector bindScope(Class<? extends Annotation> scopeAnnotation, Supplier<Scope> scope) {
        if (scopes.put(scopeAnnotation, scope) != null) {
            throw new DIException(
                    "Cannot rebind scope annotation class to a different implementation: " + scopeAnnotation);

 * Events are not visible to listeners in descendent scopes.
 *
 * <p>This annotation is used primarily to indicate to developers the scopes where this listener are available. There is also
 * some validation when a broadcaster or listener of this type is used in an incorrect scope.
 *
 * @see Scope
 */
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Inherited
public @interface EventScope {

        } else {
            val newId = scopes.putInstance(scope)
            writeSmallInt(newId)
            if (scope.parent == null) {
                writeBoolean(false)
            } else {
                writeBoolean(true)
                writeScope(scope.parent)
            }
            writeString(scope.name)
            if (scope.origin is ClassLoaderScopeOrigin.Script) {
                writeBoolean(true)

                        servicesForHomeDir.clear();
                    }
                }
                ServiceRegistry userHomeServices = ServiceRegistryBuilder.builder()
                    .scope(Scope.UserHome.class)
                    .displayName("services for Gradle user home dir " + gradleUserHomeDir)
                    .parent(sharedServices)
                    .provider(new ServiceRegistrationProvider() {