// 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 implicit conversions to interface type in a select/case
// clause are compiled correctly.

package main

import "fmt"

func main() { f[int]() }

func f[T any]() {
	ch := make(chan T)
	close(ch)

	var i, ok any
	select {
	case i, ok = <-ch:

# Issue #46092
# go list -find should always return a package with an empty Deps list

# The linker loads implicit dependencies
go list -find -f {{.Deps}} ./cmd
stdout '\[\]'

# Cgo translation may add imports of "unsafe", "runtime/cgo" and "syscall"
go list -find -f {{.Deps}} ./cgo
stdout '\[\]'

# SWIG adds imports of some standard packages
go list -find -f {{.Deps}} ./swig
stdout '\[\]'

-- go.mod --
module listfind

	"sync/atomic"
)

var _ atomic.Pointer[cgo.Incomplete]  // ERROR "cannot use incomplete \(or unallocatable\) type as a type argument: runtime/cgo\.Incomplete"
var _ atomic.Pointer[*cgo.Incomplete] // ok

func implicit(ptr *cgo.Incomplete) {
	g(ptr)  // ERROR "cannot use incomplete \(or unallocatable\) type as a type argument: runtime/cgo\.Incomplete"
	g(&ptr) // ok
}

        ProjectState projectState = projectRegistry.stateFor(project);
        if (!projectState.getOwner().isImplicitBuild()) {
            // Do not include implicit builds in workspace
            for (IdeProjectMetadata ideProjectMetadata : store.get(project)) {
                if (type.isInstance(ideProjectMetadata)) {
                    return type.cast(ideProjectMetadata);

import org.gradle.api.Project;
import org.gradle.api.Task;

import java.util.Collection;

/**
 * Service to provide all tasks in a project including both regular tasks,
 * and implicit tasks.
 */
public interface ProjectTaskLister {
    Collection<Task> listProjectTasks(Project project);

     * Declaration which do not have its PSI source and was generated, they are:
     * For regular classes, implicit default constructor is generated
     * For data classes the `copy`, `component{N}`, `toString`, `equals`, `hashCode` functions are generated
     * For enum classes the `valueOf` & `values` functions are generated
     * For lambda the `it` implicit parameter is generated
     */
    SOURCE_MEMBER_GENERATED,

    /**

     */
    IncludedBuildState addIncludedBuild(BuildDefinition buildDefinition, Path buildPath);

    /**
     * Creates an implicit included build. An implicit build is-a nested build that is managed by Gradle and whose outputs are used by dependency resolution.
     */
    IncludedBuildState addImplicitIncludedBuild(BuildDefinition buildDefinition);

    /**

env GO111MODULE=off
[short] skip # rebuilds std for alternate architecture

cd mycmd
go build mycmd

# cross-compile install with implicit GOBIN=$GOPATH/bin can make subdirectory
env GOARCH=386
[GOARCH:386] env GOARCH=amd64
env GOOS=linux
go install mycmd
exists $GOPATH/bin/linux_$GOARCH/mycmd

# cross-compile install with explicit GOBIN cannot make subdirectory
env GOBIN=$WORK/bin
! go install mycmd
! exists $GOBIN/linux_$GOARCH

 *
 * <p>An implicit variant is defined for a configuration whenever any artifacts are attached directly to this object or inherited from another configuration.</p>
 *
 * @since 3.3
 */

import org.gradle.integtests.tooling.fixture.ToolingApiSpecification
import org.gradle.tooling.model.GradleProject

class ImplicitTasksToolingApiCrossVersionSpec extends ToolingApiSpecification {

    def "implicit/placeholder tasks are visible from tooling api"() {
        file("settings.gradle") << """
            include "subproject"
        """

        when: