public class KtModuleProviderBuilder(
    public val kotlinCoreProjectEnvironment: KotlinCoreProjectEnvironment,
) {
    private val mainModules: MutableList<KtModule> = mutableListOf()

    public fun <M : KtModule> addModule(module: M): M {
        mainModules.add(module)
        return module
    }

    public lateinit var platform: TargetPlatform

    public fun build(): KtStaticProjectStructureProvider {

			continue
		}

		var (
			root, modPrefix string
			isLocal         bool
		)
		if MainModules.Contains(mod.Path) {
			if MainModules.ModRoot(mod) == "" {
				continue // If there is no main module, we can't search in it.
			}
			root = MainModules.ModRoot(mod)
			modPrefix = MainModules.PathPrefix(mod)
			isLocal = true
		} else {
			var err error
			root, isLocal, err = fetch(ctx, mod)

// list additional directives from the package under test.
func defaultGODEBUG(p *Package, directives, testDirectives, xtestDirectives []build.Directive) string {
	if p.Name != "main" {
		return ""
	}
	goVersion := modload.MainModules.GoVersion()
	if modload.RootMode == modload.NoRoot && p.Module != nil {
		// This is go install pkg@version or go run pkg@version.
		// Use the Go version from the package.
		// If there isn't one, then assume Go 1.20,

	mms := modload.MainModules

	opts := modload.PackageOpts{
		Tags:                     imports.AnyTags(),
		VendorModulesInGOROOTSrc: true,
		ResolveMissingImports:    false,
		LoadTests:                true,
		AllowErrors:              true,
		SilencePackageErrors:     true,
		SilenceUnmatchedWarnings: true,
	}
	for _, m := range mms.Versions() {
		opts.MainModule = m

# Regression test for https://go.dev/issue/58767:
# with an empty go.work file in GOPATH mode, calls to load.defaultGODEBUG for a
# package named "main" panicked in modload.MainModules.GoVersion.

env GO111MODULE=off
cd example
go list example/m

-- example/go.work --
go 1.21
-- example/m/main.go --
package main

# modules being checked for correct sums. Specifically this would happen when
# the module name sorted after the virtual 'go' version module name because
# it could not get chopped off when we removed the MainModules.Len() modules
# at the beginning of the build list and we would remove the go module instead.

go mod verify

-- go.work --
go 1.21

use (
    ./a
    ./b
)
-- a/go.mod --

// with any exclusions or replacements applied internally.
type mvsReqs struct {
	roots []module.Version
}

func (r *mvsReqs) Required(mod module.Version) ([]module.Version, error) {
	if mod.Version == "" && MainModules.Contains(mod.Path) {
		// Use the build list as it existed when r was constructed, not the current
		// global build list.
		return r.roots, nil
	}

	if mod.Version == "none" {
		return nil, nil
	}

private fun getTestDataContext(testServices: TestServices): TestDataContext {
    var psiDeclaration: PsiElement? = null
    var useSitePosition: PsiElement? = null

    testServices.ktTestModuleStructure.mainModules.forEach { ktTestModule ->
        val psiFiles = ktTestModule.files
        for (psiFile in psiFiles) {
            val targetOffset = testServices.expressionMarkerProvider.getCaretPositionOrNull(psiFile)

    override fun doTest(testServices: TestServices) {
        val mainModule = testServices.ktTestModuleStructure.mainModules
            .let { modules -> if (modules.size == 1) modules.first() else fail("Expected single main module. Found $modules") }

        val libraryModule = mainModule.ktModule as? KtLibraryModule
            ?: fail("Expected main module '${mainModule.ktModule}' to be '${KtLibraryModule::class.simpleName}'")

            registerService(ModuleVisibilityManager::class.java, CliModuleVisibilityManagerImpl(enabled = true))
        }

        testServices.ktTestModuleStructure.mainModules.forEach { ktTestModule ->
            val sourceModule = ktTestModule.ktModule as? KtSourceModule ?: return@forEach
            AnalysisHandlerExtension.registerExtension(project, KaFe10AnalysisHandlerExtension(sourceModule))