// LSB-first representation is a hexadecimal number with n bits, in which the
	// most significant bit represents the coefficient of x⁰ and the least significant
	// bit represents the coefficient of xⁿ⁻¹ (the coefficient for xⁿ is implicit).
	//
	// For example, CRC32-Q, as defined by the following polynomial,
	//	x³²+ x³¹+ x²⁴+ x²²+ x¹⁶+ x¹⁴+ x⁸+ x⁷+ x⁵+ x³+ x¹+ x⁰
	// has the reversed notation 0b11010101100000101000001010000001, so the value

// run

// Copyright 2022 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Test that identifiers in implicit (omitted) RHS
// expressions of constant declarations are resolved
// in the correct context; see issues #49157, #53585.

package main

const X = 2

func main() {
	const (
		A    = iota // 0
		iota = iota // 1

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

# split-incompatible/subpkg module). modload.QueryPattern will suggest
# split-incompatible v2.0.0+incompatible, which we cannot use (because it would
# be an implicit downgrade), and split-incompatible/subpkg v0.1.0, which we
# *should* use.

go mod tidy

go list -m all
stdout '^example.com/split-incompatible/subpkg v0\.1\.0$'
! stdout '^example.com/split-incompatible .*'

// errorcheck

// Copyright 2009 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Verify compiler complains about missing implicit methods.
// Does not compile.

package main

type T int

func (t T) V()
func (t *T) P()

type V interface {
	V()
}
type P interface {
	P()
	V()
}

type S struct {
	T
}

== 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_.