* limitations under the License.
 */

package org.gradle.internal.service.scopes;

/**
 * @see ServiceScope
 */
public interface Scope {

    /**
     * These services are reused across builds in the same process.
     *
     * <p>Global services are visible to all other services.</p>
     */
    interface Global extends Scope {}

    /**

     *       fun foo() { // scope5  FirLocalScope - enum entry: Local
     *
     *         // Distance to scopes from <element> in the order from the closest:
     *         //   scope5 -> scope4 -> scope6 -> scope3 -> scope1 -> scope2
     *         <element>
     *
     *       }
     *       companion object {

 * 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)

    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)

        fullyPrintScope: (KaScopeKind) -> Boolean,
    ) {
        for (scopeWithKind in scopeContext.scopes) {
            renderForTests(scopeWithKind.scope, scopeWithKind.kind, printer, printPretty, fullyPrintScope)
            printer.appendLine()
        }
    }

    private fun KaSession.renderForTests(
        scope: KaScope,
        scopeKind: KaScopeKind,
        printer: PrettyPrinter,
        printPretty: Boolean,

            } else {
                scope.exportClassLoader
            }
        } else {
            this.classLoader
        }
        val newType = Class.forName(name, false, classLoader)
        classes.putInstance(id, newType)
        return newType
    }

    private
    fun ReadContext.readScope(): ClassLoaderScope {
        val id = readSmallInt()
        val scope = scopes.getInstance(id)

package org.gradle.initialization;

import org.gradle.internal.dispatch.Dispatch;
import org.gradle.internal.service.scopes.Scope;
import org.gradle.internal.service.scopes.ServiceScope;

/**
 * A consumer for build events provided by the build requester. This can be used to forward events to the build requester.
 */
@ServiceScope(Scope.BuildSession.class)
public interface BuildEventConsumer extends Dispatch<Object> {

import org.gradle.internal.serialize.graph.BeanStateWriter
import org.gradle.internal.serialize.graph.BeanStateWriterLookup
import org.gradle.internal.service.scopes.Scope
import org.gradle.internal.service.scopes.ServiceScope
import java.util.concurrent.ConcurrentHashMap


@ServiceScope(Scope.BuildTree::class)
class DefaultBeanStateWriterLookup : BeanStateWriterLookup {
    private