/**
 * [KotlinPackageProviderMerger] allows merging multiple [KotlinPackageProvider]s into a more efficient package provider.
 *
 * Package providers should not be naively merged by combining scopes and calling [createPackageProvider], because there may be additional
 * package providers which do not operate based on scopes (e.g. resolve extension package providers).
 */

# For 1.23+, vendored packages that are missing in modules.txt should result in an error.
cp incorrect_modules.txt vendor/modules.txt
# incorrect_modules is missing foo.com/internal/bar/b so the build should fail.
! go build ./vendor/foo.com/internal/bar/a
stderr 'cannot find module providing package foo.com/internal/bar/b: import lookup disabled by -mod=vendor'

// MODULE: lib1
// FILE: dependency.kt
package usage

fun implicitType() = 1

// MODULE: dep(lib1)
// FILE: annotation.kt
package usage

fun implicitTypeFromAnotherModule() = implicitType()

// MODULE: lib2
// FILE: dependency.kt
package usage

fun implicitType() = "str"

// MODULE: main(lib2, dep)
// FILE: usage.kt
package usage

fun usage(): Int = run {
    implicitType()

 */

package org.jetbrains.kotlin.analysis.api

import org.jetbrains.kotlin.analysis.api.types.KaStarTypeProjection
import org.jetbrains.kotlin.analysis.api.types.KaTypeArgumentWithVariance
import org.jetbrains.kotlin.analysis.api.types.KaTypeProjection

@Deprecated(
    "The API has been moved into `org.jetbrains.kotlin.analysis.api.types` package",
    level = DeprecationLevel.HIDDEN,
)

ImportPath: "m/b", Imports: "[m/c]", ImportMap: "map[]"
-- go.mod --
module m

go 1.23

-- a/a.go --
package main

import _ "m/b"
-- a/default.pgo --
-- b/b.go --
package a

import _ "m/c"

-- c/c.go --

# Build with the generated file.
go build

-- go.mod --
module cgolongcmd

go 1.22
-- generate.go --
//go:build ignore

package main

import (
	"fmt"
	"log"
	"os"
	"bytes"
)

func main() {
	var buf bytes.Buffer
	buf.WriteString("package p\n")
	buf.WriteString("// #cgo LDFLAGS:")
	for i := range 10000 {
		fmt.Fprintf(&buf, " -Wl,-rpath,/nonexistentpath/%d", i)
	}

	t.Fatalf("FAIL - %s", t.Name())
}
-- a/a_test.go --
package a

import "testing"

func TestFailingPkgA(t *testing.T) {
	t.Errorf("FAIL - %s", t.Name())
}
-- b/b_test.go --
package b

import "testing"

func TestFailingPkgB(t *testing.T) {
	t.Errorf("FAIL - %s", t.Name())
}
-- c/c_test.go --
package c

import "testing"

func TestFailingPkgC(t *testing.T) {

-- .mod --
// no longer deprecated
module example.com/undeprecated

go 1.17
-- go.mod --
// no longer deprecated
module example.com/undeprecated

go 1.17
-- undeprecated.go --
package undeprecated

-- cmd/a/a.go --
package main

import "fmt"

-- b/default.pgo --
-- nopgo/nopgo.go --
package main
import _ "test/dep"
import _ "test/dep2"
func main() {}
-- nopgo/nopgo_test.go --
package main
import "testing"
func TestNopgo(*testing.T) {}
-- dep/dep.go --
package dep
import _ "test/dep3"
-- dep2/dep2.go --
package dep2
-- dep3/dep3.go --
package dep3
-- testdep/testdep.go --
package testdep
import _ "test/testdep2"

"vendor/golang.org/x/crypto/cryptobyte". When a package with the
same path is imported from a package outside std or cmd, it will
be resolved normally. Consequently, a binary may be built with two
copies of a package at different versions if the package is
imported normally and vendored by the standard library.

Vendored packages are internally renamed with a "vendor/" prefix
to preserve the invariant that all packages have distinct paths.