/**
 * An instantiator which is responsible for allowing the capture of implicit
 * inputs provided by injected services. For this to be possible, a capturing
 * instantiator "session" must be created before the instance is created. This
 * must be done by calling the {@link #capturing(ImplicitInputRecorder)} method
 * which provides a registrar which will record implicit inputs.
 *

                // For implicit invoke, we resolve the calleeExpression of the CallExpression to the call that creates the receiver of this
                // implicit invoke call. For example,
                // ```
                // fun test(f: () -> Unit) {
                //   f() // calleeExpression `f` resolves to the local variable access, while `f()` resolves to the implicit `invoke` call.

     * First, attribute matching is performed against the implicit variants of each consumable configuration.
     * Then, assuming attribute matching returns a single matched configuration, Gradle will then perform
     * attribute matching against each sub-variant (including the implicit) of the matched configuration.
     * <p>

 * limitations under the License.
 */

package org.gradle.kotlin.dsl.support

import kotlin.reflect.KClass


/**
 * Associates a script template with the type of its implicit receiver
 * which must match the type of the given [KotlinScriptHost.target].
 */
internal

env GO111MODULE=on
env GOTRACEBACK=single

# Go 1.21 work module should leave panicnil with an implicit default.
cp go.mod.21 go.mod
go list -f '{{.Module.GoVersion}} {{.DefaultGODEBUG}}'
! stdout panicnil
stdout randautoseed=0

# Go 1.21 work module should NOT set panicnil=1 in Go 1.20 dependency.
cp go.mod.21 go.mod
go list -f '{{.Module.GoVersion}} {{.DefaultGODEBUG}}' q
! stdout panicnil=1
! stdout randautoseed

== Capability coordinates

A _capability_ is defined by a `(group, module, version)` triplet.
Each component defines an implicit capability corresponding to its GAV coordinates (group, artifact, version).
For example, the `org.apache.commons:commons-lang3:3.8` module has an implicit capability with group `org.apache.commons`, name `commons-lang3` and version `3.8`.
It is important to realize that capabilities are _versioned_.

        .singleOrNull()
}

/**
 * Implicit dispatch receiver is present when an extension function declared in object
 * is imported somewhere else and used without directly referencing the object instance
 * itself:
 *
 * ```kt
 * import Foo.bar
 *
 * object Foo { fun String.bar() {} }
 *
 * fun usage() {
 *   "hello".bar() // this call has implicit 'Foo' dispatch receiver
 * }
 * ```
 */

		for x := n.X; ; {
			var inner ir.Node
			implicit := false
			switch x := x.(type) {
			case *ir.AddrExpr:
				inner, implicit = x.X, x.Implicit()
			case *ir.SelectorExpr:
				inner, implicit = x.X, x.Implicit()
			case *ir.StarExpr:
				inner, implicit = x.X, x.Implicit()
			}
			if !implicit {
				break
			}

import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * Attached to the getter for a property on a {@link RuleSource} to denote that the property defines an implicit input for all rules defined by the rule source.
 */
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
@Incubating
public @interface RuleInput {

 */
public interface AnnotatedServiceLifecycleHandler {
    List<Class<? extends Annotation>> getAnnotations();

    /**
     * When not null, all services are considered to have the implicit annotation
     * and the handler should be notified about all registrations.
     */
    @Nullable
    Class<? extends Annotation> getImplicitAnnotation();

    /**