[Gradle] Remove requiresVisibilityOf API and related checks

^KT-58228 Verification Pending

libraries/tools/kotlin-gradle-plugin-api/api/kotlin-gradle-plugin-api.api

@@ -1060,14 +1060,12 @@ public abstract interface class org/jetbrains/kotlin/gradle/plugin/KotlinSourceS
 	public abstract fun getImplementationMetadataConfigurationName ()Ljava/lang/String;
 	public abstract fun getKotlin ()Lorg/gradle/api/file/SourceDirectorySet;
 	public abstract fun getLanguageSettings ()Lorg/jetbrains/kotlin/gradle/plugin/LanguageSettingsBuilder;
-	public abstract fun getRequiresVisibilityOf ()Ljava/util/Set;
 	public abstract fun getResources ()Lorg/gradle/api/file/SourceDirectorySet;
 	public abstract fun getRuntimeOnlyMetadataConfigurationName ()Ljava/lang/String;
 	public abstract fun kotlin (Lkotlin/jvm/functions/Function1;)Lorg/gradle/api/file/SourceDirectorySet;
 	public abstract fun kotlin (Lorg/gradle/api/Action;)Lorg/gradle/api/file/SourceDirectorySet;
 	public abstract fun languageSettings (Lkotlin/jvm/functions/Function1;)Lorg/jetbrains/kotlin/gradle/plugin/LanguageSettingsBuilder;
 	public abstract fun languageSettings (Lorg/gradle/api/Action;)Lorg/jetbrains/kotlin/gradle/plugin/LanguageSettingsBuilder;
-	public abstract fun requiresVisibilityOf (Lorg/jetbrains/kotlin/gradle/plugin/KotlinSourceSet;)V
 }
 
 public final class org/jetbrains/kotlin/gradle/plugin/KotlinSourceSet$Companion {

libraries/tools/kotlin-gradle-plugin-api/src/common/kotlin/org/jetbrains/kotlin/gradle/plugin/KotlinSourceSet.kt

@@ -43,12 +43,6 @@ interface KotlinSourceSet : Named, HasProject, HasMutableExtras, HasKotlinDepend
         const val COMMON_TEST_SOURCE_SET_NAME = "commonTest"
     }
 
-    @Deprecated("Scheduled for removal with Kotlin 2.0")
-    val requiresVisibilityOf: Set<KotlinSourceSet>
-
-    @Deprecated("Scheduled for removal with Kotlin 2.0")
-    fun requiresVisibilityOf(other: KotlinSourceSet)
-
     val customSourceFilesExtensions: Iterable<String> // lazy iterable expected
     fun addCustomSourceFilesExtensions(extensions: List<String>) {}
 }

libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/NewMultiplatformIT.kt

@@ -1780,14 +1780,6 @@ open class NewMultiplatformIT : BaseGradleIT() {
                 // Native:
                 assertFileExists("build/classes/kotlin/linux64/integrationTest/klib/new-mpp-associate-compilations_integrationTest.klib")
             }
-
-            gradleBuildScript().appendText(
-                "\nkotlin.sourceSets { getByName(\"commonTest\").requiresVisibilityOf(getByName(\"commonIntegrationTest\")) }"
-            )
-            build {
-                assertFailed()
-                assertContains(UnsatisfiedSourceSetVisibilityException::class.java.simpleName)
-            }
         }
     }
 

libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/new-mpp-associate-compilations/build.gradle

@@ -22,10 +22,7 @@ kotlin {
             }
         }
 
-        create("commonIntegrationTest") {
+        create("commonIntegrationTest")
-            requiresVisibilityOf(getByName("commonMain"))
-            requiresVisibilityOf(getByName("commonTest"))
-        }
     }
 
     jvm {
@@ -57,9 +54,6 @@ kotlin {
         compilations.create("integrationTest") {
             associateWith(compilations["test"])
             defaultSourceSet.dependsOn(sourceSets["commonIntegrationTest"])
-            defaultSourceSet.requiresVisibilityOf(sourceSets["commonMain"])
-            defaultSourceSet.requiresVisibilityOf(sourceSets["commonTest"])
-            defaultSourceSet.requiresVisibilityOf(sourceSets["commonIntegrationTest"])
         }
     }
 }

libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/plugin/mpp/KotlinMultiplatformPlugin.kt

@@ -22,10 +22,8 @@ import org.jetbrains.kotlin.gradle.plugin.ide.locateOrRegisterIdeResolveDependen
 import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinMultiplatformPlugin.Companion.sourceSetFreeCompilerArgsPropertyName
 import org.jetbrains.kotlin.gradle.plugin.mpp.apple.addBuildListenerForXcode
 import org.jetbrains.kotlin.gradle.plugin.mpp.internal.runDeprecationDiagnostics
-import org.jetbrains.kotlin.gradle.plugin.mpp.pm20.util.copyAttributes
 import org.jetbrains.kotlin.gradle.plugin.sources.DefaultLanguageSettingsBuilder
 import org.jetbrains.kotlin.gradle.plugin.sources.awaitPlatformCompilations
-import org.jetbrains.kotlin.gradle.plugin.sources.checkSourceSetVisibilityRequirements
 import org.jetbrains.kotlin.gradle.plugin.sources.internal
 import org.jetbrains.kotlin.gradle.plugin.statistics.KotlinBuildStatsService
 import org.jetbrains.kotlin.gradle.scripting.internal.ScriptingGradleSubplugin
@@ -174,12 +172,6 @@ class KotlinMultiplatformPlugin : Plugin<Project> {
         project.launch {
             project.setupDefaultKotlinHierarchy()
         }
-
-        project.launchInStage(KotlinPluginLifecycle.Stage.ReadyForExecution) {
-            project.runProjectConfigurationHealthCheck {
-                checkSourceSetVisibilityRequirements(project)
-            }
-        }
     }
 
     private fun setupTargetsBuildStatsReport(project: Project) {

libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/plugin/sources/DefaultKotlinSourceSet.kt

@@ -121,18 +121,6 @@ abstract class DefaultKotlinSourceSet @Inject constructor(
         explicitlyAddedCustomSourceFilesExtensions.addAll(extensions)
     }
 
-
-    private val _requiresVisibilityOf = mutableSetOf<KotlinSourceSet>()
-
-    @Deprecated("Scheduled for removal with Kotlin 2.0")
-    override val requiresVisibilityOf: MutableSet<KotlinSourceSet>
-        get() = Collections.unmodifiableSet(_requiresVisibilityOf)
-
-    @Deprecated("Scheduled for removal with Kotlin 2.0")
-    override fun requiresVisibilityOf(other: KotlinSourceSet) {
-        _requiresVisibilityOf += other
-    }
-
     //region IDE import for Granular source sets metadata
 
     data class MetadataDependencyTransformation(

libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/plugin/sources/SourceSetsVisibilityInference.kt

@@ -118,31 +118,4 @@ class UnsatisfiedSourceSetVisibilityException(
                 append("\n")
             }
         }
-}
+}
-
-fun checkSourceSetVisibilityRequirements(project: Project) = checkSourceSetVisibilityRequirements(
-    project.kotlinExtension.sourceSets
-)
-
-internal fun checkSourceSetVisibilityRequirements(
-    sourceSets: Iterable<KotlinSourceSet>,
-) {
-    sourceSets.forEach { sourceSet ->
-        val requiredVisibility = sourceSet.requiresVisibilityOf
-        val inferredVisibility =
-            getVisibleSourceSetsFromAssociateCompilations(sourceSet.internal.compilations)
-
-        val requiredButNotVisible = requiredVisibility - inferredVisibility - sourceSet.internal.withDependsOnClosure
-
-        if (requiredButNotVisible.isNotEmpty()) {
-            val compilations = sourceSet.internal.compilations
-
-            throw UnsatisfiedSourceSetVisibilityException(
-                sourceSet,
-                compilations,
-                inferredVisibility,
-                requiredButNotVisible
-            )
-        }
-    }
-}

libraries/tools/kotlin-gradle-plugin/src/functionalTest/kotlin/org/jetbrains/kotlin/gradle/unitTests/sources/SourceSetVisibilityFromAssociatedCompilationsTest.kt

@@ -0,0 +1,170 @@
+/*
+ * Copyright 2010-2023 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+@file:Suppress("DuplicatedCode")
+
+package org.jetbrains.kotlin.gradle.unitTests.sources
+
+import org.jetbrains.kotlin.gradle.dsl.multiplatformExtension
+import org.jetbrains.kotlin.gradle.plugin.KotlinSourceSet
+import org.jetbrains.kotlin.gradle.plugin.sources.getVisibleSourceSetsFromAssociateCompilations
+import org.jetbrains.kotlin.gradle.plugin.sources.internal
+import org.jetbrains.kotlin.gradle.util.buildProjectWithMPP
+import org.jetbrains.kotlin.util.capitalizeDecapitalize.decapitalizeAsciiOnly
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertNotNull
+
+class SourceSetVisibilityFromAssociatedCompilationsTest {
+    private val project = buildProjectWithMPP()
+    private val kotlin = project.multiplatformExtension.apply {
+        applyDefaultHierarchyTemplate()
+    }
+
+    @Test
+    fun testBasicSuccessful() {
+        kotlin.jvm()
+        kotlin.linuxX64()
+        val commonMain = kotlin.sourceSets.getByName("commonMain")
+        val commonTest = kotlin.sourceSets.getByName("commonTest")
+        val jvmMain = kotlin.sourceSets.getByName("jvmMain")
+        val jvmTest = kotlin.sourceSets.getByName("jvmTest")
+
+        jvmTest.assertVisibleSourceSetsFromAssociatedCompilations(commonMain, jvmMain)
+        commonTest.assertVisibleSourceSetsFromAssociatedCompilations(commonMain)
+    }
+
+    @Test
+    fun testBambooSourceSetStructureVisibility() {
+        kotlin.apply {
+            jvm()
+            iosArm64()
+            iosX64()
+
+            sourceSets.apply {
+                // NB: nativeTest sees iosMain because it participates only in iosX64 and iosArm64 test compilations.
+                nativeTest.get().assertVisibleSourceSetsFromAssociatedCompilations(
+                    iosMain.get(),
+                    appleMain.get(),
+                    nativeMain.get(),
+                    commonMain.get(),
+                )
+                commonTest.get().assertVisibleSourceSetsFromAssociatedCompilations(commonMain.get())
+            }
+        }
+    }
+
+    @Test
+    fun testCustomCompilationWithoutAssociation() {
+        val jvm = kotlin.jvm()
+        val commonTest = kotlin.sourceSets.getByName("commonTest")
+        val jvmSpecialTest = kotlin.sourceSets.create("jvmSpecialTest")
+
+        jvmSpecialTest.dependsOn(commonTest)
+
+        val jvmSpecialTestCompilation = jvm.compilations.create("specialTest") // note: No association with jvmMain!
+        assertEquals(jvmSpecialTest, jvmSpecialTestCompilation.defaultSourceSet)
+
+        jvmSpecialTest.assertVisibleSourceSetsFromAssociatedCompilations(*arrayOf())
+    }
+
+    @Test
+    fun testCustomCompilationAssociatesWithMainCompilation() {
+        val jvm = kotlin.jvm()
+        kotlin.linuxX64()
+
+        val commonTest = kotlin.sourceSets.getByName("commonTest")
+        val commonMain = kotlin.sourceSets.getByName("commonMain")
+        val jvmMain = kotlin.sourceSets.getByName("jvmMain")
+        val jvmSpecialTest = kotlin.sourceSets.create("jvmSpecialTest")
+
+        jvmSpecialTest.dependsOn(commonTest)
+
+        val jvmSpecialTestCompilation = jvm.compilations.create("specialTest")
+        assertEquals(jvmSpecialTest, jvmSpecialTestCompilation.defaultSourceSet)
+
+        jvmSpecialTestCompilation.associateWith(jvm.compilations.getByName("main"))
+
+        jvmSpecialTest.assertVisibleSourceSetsFromAssociatedCompilations(commonMain, jvmMain)
+    }
+
+    @Test
+    fun testInferenceForHierarchy() {
+        kotlin.jvm()
+        kotlin.js()
+        kotlin.linuxX64("linux")
+
+        listOf("Main", "Test").forEach { suffix ->
+            val common = kotlin.sourceSets.getByName("common$suffix")
+            val jvmAndJs = kotlin.sourceSets.create("jvmAndJs$suffix")
+            val linuxAndJs = kotlin.sourceSets.create("linuxAndJs$suffix")
+            val jvm = kotlin.sourceSets.getByName("jvm$suffix")
+            val linux = kotlin.sourceSets.getByName("linux$suffix")
+            val js = kotlin.sourceSets.getByName("js$suffix")
+
+            jvmAndJs.dependsOn(common)
+            linuxAndJs.dependsOn(common)
+
+            jvm.dependsOn(jvmAndJs)
+            js.dependsOn(jvmAndJs)
+            js.dependsOn(linuxAndJs)
+            linux.dependsOn(linuxAndJs)
+        }
+
+        "commonMain".assertVisibleSourceSetsFromAssociatedCompilations(*arrayOf())
+        "jvmMain".assertVisibleSourceSetsFromAssociatedCompilations(*arrayOf())
+        "jvmAndJsMain".assertVisibleSourceSetsFromAssociatedCompilations(*arrayOf())
+
+        "commonTest".assertVisibleSourceSetsFromAssociatedCompilations("commonMain")
+        "jvmAndJsTest".assertVisibleSourceSetsFromAssociatedCompilations("commonMain", "jvmAndJsMain")
+        "linuxAndJsTest".assertVisibleSourceSetsFromAssociatedCompilations("commonMain", "linuxAndJsMain")
+        "jvmTest".assertVisibleSourceSetsFromAssociatedCompilations("commonMain", "jvmAndJsMain", "jvmMain")
+    }
+
+    @Test
+    fun testInferenceThroughIndirectAssociation() {
+        kotlin.jvm()
+        kotlin.js()
+
+        listOf(null, "Main", "Test", "IntegrationTest").zipWithNext().forEach { (previousSuffix, suffix) ->
+            val common = kotlin.sourceSets.maybeCreate("common$suffix")
+            val jvm = kotlin.sourceSets.maybeCreate("jvm$suffix")
+            val js = kotlin.sourceSets.maybeCreate("js$suffix")
+
+            if (previousSuffix != null) {
+                assertNotNull(suffix)
+                jvm.dependsOn(common)
+                js.dependsOn(common)
+
+                val previousJvmCompilation = kotlin.jvm().compilations.maybeCreate(previousSuffix.decapitalizeAsciiOnly())
+                val jvmCompilation = kotlin.jvm().compilations.maybeCreate(suffix.decapitalizeAsciiOnly())
+                assertEquals(jvm, jvmCompilation.defaultSourceSet)
+                jvmCompilation.associateWith(previousJvmCompilation)
+
+                val previousJsCompilation = kotlin.js().compilations.maybeCreate(previousSuffix.decapitalizeAsciiOnly())
+                val jsCompilation = kotlin.js().compilations.maybeCreate(suffix.decapitalizeAsciiOnly())
+                assertEquals(js, jsCompilation.defaultSourceSet)
+                jsCompilation.associateWith(previousJsCompilation)
+            }
+        }
+
+        "commonIntegrationTest".assertVisibleSourceSetsFromAssociatedCompilations("commonMain", "commonTest")
+        "jvmIntegrationTest".assertVisibleSourceSetsFromAssociatedCompilations("commonMain", "jvmMain", "commonTest", "jvmTest")
+    }
+
+    private fun String.assertVisibleSourceSetsFromAssociatedCompilations(
+        vararg expectedVisibleSourceSets: String
+    ) = assertEquals(
+        expectedVisibleSourceSets.toSet(),
+        getVisibleSourceSetsFromAssociateCompilations(kotlin.sourceSets.getByName(this).internal.compilations).map { it.name }.toSet()
+    )
+
+    private fun KotlinSourceSet.assertVisibleSourceSetsFromAssociatedCompilations(
+        vararg expectedVisibleSourceSets: KotlinSourceSet
+    ) = assertEquals(
+        expectedVisibleSourceSets.map { it.name }.toSet(),
+        getVisibleSourceSetsFromAssociateCompilations(this.internal.compilations).map { it.name }.toSet()
+    )
+}

libraries/tools/kotlin-gradle-plugin/src/functionalTest/kotlin/org/jetbrains/kotlin/gradle/unitTests/sources/SourceSetVisibilityInferenceTest.kt

@@ -1,218 +0,0 @@
-/*
- * Copyright 2010-2022 JetBrains s.r.o. and Kotlin Programming Language contributors.
- * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
- */
-
-@file:Suppress("DuplicatedCode")
-
-package org.jetbrains.kotlin.gradle.unitTests.sources
-
-import org.jetbrains.kotlin.gradle.dsl.multiplatformExtension
-import org.jetbrains.kotlin.gradle.plugin.KotlinSourceSet
-import org.jetbrains.kotlin.gradle.plugin.sources.UnsatisfiedSourceSetVisibilityException
-import org.jetbrains.kotlin.gradle.plugin.sources.checkSourceSetVisibilityRequirements
-import org.jetbrains.kotlin.gradle.plugin.sources.getVisibleSourceSetsFromAssociateCompilations
-import org.jetbrains.kotlin.gradle.plugin.sources.internal
-import org.jetbrains.kotlin.gradle.util.buildProjectWithMPP
-import org.jetbrains.kotlin.util.capitalizeDecapitalize.decapitalizeAsciiOnly
-import kotlin.test.Test
-import kotlin.test.assertEquals
-import kotlin.test.assertFailsWith
-import kotlin.test.assertNotNull
-
-@Suppress("DEPRECATION")
-class SourceSetVisibilityInferenceTest {
-    private val project = buildProjectWithMPP()
-    private val kotlin = project.multiplatformExtension.apply {
-        applyDefaultHierarchyTemplate()
-    }
-
-    @Test
-    fun testBasicSuccessful() {
-        kotlin.jvm()
-        val commonMain = kotlin.sourceSets.getByName("commonMain")
-        val commonTest = kotlin.sourceSets.getByName("commonTest")
-        val jvmMain = kotlin.sourceSets.getByName("jvmMain")
-        val jvmTest = kotlin.sourceSets.getByName("jvmTest")
-
-        commonTest.requiresVisibilityOf(commonMain)
-        jvmTest.requiresVisibilityOf(jvmMain)
-
-        jvmTest.checkInferredSourceSetsVisibility(commonMain, jvmMain)
-        checkSourceSetVisibilityRequirements(kotlin.sourceSets)
-    }
-
-    @Test
-    fun testFailureWithNoAssociation() {
-        val jvm = kotlin.jvm()
-        val commonMain = kotlin.sourceSets.getByName("commonMain")
-        val commonTest = kotlin.sourceSets.getByName("commonTest")
-        val jvmMain = kotlin.sourceSets.getByName("jvmMain")
-        val jvmSpecialTest = kotlin.sourceSets.create("jvmSpecialTest")
-
-        commonTest.requiresVisibilityOf(commonMain)
-        jvmSpecialTest.requiresVisibilityOf(jvmMain)
-        jvmSpecialTest.dependsOn(commonTest)
-
-        val jvmTestCompilation = jvm.compilations.getByName("test")
-        val jvmSpecialTestCompilation = jvm.compilations.create("specialTest") // note: No association with jvmMain!
-        assertEquals(jvmSpecialTest, jvmSpecialTestCompilation.defaultSourceSet)
-
-        jvmSpecialTest.checkInferredSourceSetsVisibility(*arrayOf())
-
-        assertFailsWith<UnsatisfiedSourceSetVisibilityException> {
-            checkSourceSetVisibilityRequirements(setOf(jvmSpecialTest))
-        }.apply {
-            assertEquals(jvmSpecialTest, sourceSet)
-            assertEquals(emptyList(), visibleSourceSets)
-            assertEquals(setOf(jvmMain), requiredButNotVisible)
-            assertEquals(setOf(jvmSpecialTestCompilation), compilations)
-        }
-
-        assertFailsWith<UnsatisfiedSourceSetVisibilityException> {
-            checkSourceSetVisibilityRequirements(setOf(commonTest))
-        }.apply {
-            assertEquals(commonTest, sourceSet)
-            assertEquals(emptyList(), visibleSourceSets)
-            assertEquals(setOf(commonMain), requiredButNotVisible)
-            assertEquals(setOf(jvmTestCompilation, jvmSpecialTestCompilation), compilations)
-        }
-    }
-
-    @Test
-    fun testInferenceForHierarchy() {
-        kotlin.jvm()
-        kotlin.js()
-        kotlin.linuxX64("linux")
-
-        listOf("Main", "Test").forEach { suffix ->
-            val common = kotlin.sourceSets.getByName("common$suffix")
-            val jvmAndJs = kotlin.sourceSets.create("jvmAndJs$suffix")
-            val linuxAndJs = kotlin.sourceSets.create("linuxAndJs$suffix")
-            val jvm = kotlin.sourceSets.getByName("jvm$suffix")
-            val linux = kotlin.sourceSets.getByName("linux$suffix")
-            val js = kotlin.sourceSets.getByName("js$suffix")
-
-            if (suffix == "Test") {
-                jvmAndJs.requiresVisibilityOf(kotlin.sourceSets.getByName("jvmAndJsMain"))
-                linuxAndJs.requiresVisibilityOf(kotlin.sourceSets.getByName("linuxAndJsMain"))
-                jvm.requiresVisibilityOf(kotlin.sourceSets.getByName("jvmMain"))
-                linux.requiresVisibilityOf(kotlin.sourceSets.getByName("linuxMain"))
-                js.requiresVisibilityOf(kotlin.sourceSets.getByName("jsMain"))
-            }
-
-            jvmAndJs.dependsOn(common)
-            linuxAndJs.dependsOn(common)
-
-            jvm.dependsOn(jvmAndJs)
-            js.dependsOn(jvmAndJs)
-            js.dependsOn(linuxAndJs)
-            linux.dependsOn(linuxAndJs)
-        }
-
-        "commonMain".checkInferredSourceSetsVisibility(*arrayOf())
-        "jvmMain".checkInferredSourceSetsVisibility(* arrayOf())
-        "jvmAndJsMain".checkInferredSourceSetsVisibility(*arrayOf())
-
-        "commonTest".checkInferredSourceSetsVisibility("commonMain")
-        "jvmAndJsTest".checkInferredSourceSetsVisibility("commonMain", "jvmAndJsMain")
-        "linuxAndJsTest".checkInferredSourceSetsVisibility("commonMain", "linuxAndJsMain")
-        "jvmTest".checkInferredSourceSetsVisibility("commonMain", "jvmAndJsMain", "jvmMain")
-
-        checkSourceSetVisibilityRequirements(kotlin.sourceSets)
-    }
-
-    @Test
-    fun testInferenceThroughIndirectAssociation() {
-        kotlin.jvm()
-        kotlin.js()
-
-        listOf(null, "Main", "Test", "IntegrationTest").zipWithNext().forEach { (previousSuffix, suffix) ->
-            val common = kotlin.sourceSets.maybeCreate("common$suffix")
-            val jvm = kotlin.sourceSets.maybeCreate("jvm$suffix")
-            val js = kotlin.sourceSets.maybeCreate("js$suffix")
-
-            if (previousSuffix != null) {
-                assertNotNull(suffix)
-                common.requiresVisibilityOf(kotlin.sourceSets.getByName("common$previousSuffix"))
-                jvm.requiresVisibilityOf(kotlin.sourceSets.getByName("jvm$previousSuffix"))
-                js.requiresVisibilityOf(kotlin.sourceSets.getByName("js$previousSuffix"))
-                jvm.dependsOn(common)
-                js.dependsOn(common)
-
-                val previousJvmCompilation = kotlin.jvm().compilations.maybeCreate(previousSuffix.decapitalizeAsciiOnly())
-                val jvmCompilation = kotlin.jvm().compilations.maybeCreate(suffix.decapitalizeAsciiOnly())
-                assertEquals(jvm, jvmCompilation.defaultSourceSet)
-                jvmCompilation.associateWith(previousJvmCompilation)
-
-                val previousJsCompilation = kotlin.js().compilations.maybeCreate(previousSuffix.decapitalizeAsciiOnly())
-                val jsCompilation = kotlin.js().compilations.maybeCreate(suffix.decapitalizeAsciiOnly())
-                assertEquals(js, jsCompilation.defaultSourceSet)
-                jsCompilation.associateWith(previousJsCompilation)
-            }
-        }
-
-        "commonIntegrationTest".checkInferredSourceSetsVisibility("commonMain", "commonTest")
-        "jvmIntegrationTest".checkInferredSourceSetsVisibility("commonMain", "jvmMain", "commonTest", "jvmTest")
-        checkSourceSetVisibilityRequirements(kotlin.sourceSets)
-    }
-
-    @Test
-    fun testInferenceThroughIndirectAssociationWithMissingAssociateWith() {
-        kotlin.jvm()
-        kotlin.js()
-
-        listOf(null, "Main", "Test", "IntegrationTest").zipWithNext().forEach { (previousSuffix, suffix) ->
-            val common = kotlin.sourceSets.maybeCreate("common$suffix")
-            val jvm = kotlin.sourceSets.maybeCreate("jvm$suffix")
-            val js = kotlin.sourceSets.maybeCreate("js$suffix")
-
-            if (previousSuffix != null) {
-                assertNotNull(suffix)
-                common.requiresVisibilityOf(kotlin.sourceSets.getByName("common$previousSuffix"))
-                jvm.requiresVisibilityOf(kotlin.sourceSets.getByName("jvm$previousSuffix"))
-                js.requiresVisibilityOf(kotlin.sourceSets.getByName("js$previousSuffix"))
-                jvm.dependsOn(common)
-                js.dependsOn(common)
-
-                val jvmCompilation = kotlin.jvm().compilations.maybeCreate(suffix.decapitalizeAsciiOnly())
-                assertEquals(jvm, jvmCompilation.defaultSourceSet)
-
-                val jsCompilation = kotlin.js().compilations.maybeCreate(suffix.decapitalizeAsciiOnly())
-                assertEquals(js, jsCompilation.defaultSourceSet)
-            }
-        }
-
-        val commonIntegrationTest = kotlin.sourceSets.getByName("commonIntegrationTest")
-        commonIntegrationTest.requiresVisibilityOf(kotlin.sourceSets.getByName("commonMain"))
-
-        assertFailsWith<UnsatisfiedSourceSetVisibilityException> {
-            checkSourceSetVisibilityRequirements(setOf(commonIntegrationTest))
-        }.apply {
-            assertEquals(commonIntegrationTest, this.sourceSet)
-            assertEquals(setOf(), visibleSourceSets.map { it.name }.toSet())
-            assertEquals(setOf("commonTest", "commonMain"), requiredButNotVisible.map { it.name }.toSet())
-            assertEquals(
-                setOf(
-                    kotlin.jvm().compilations.getByName("integrationTest"),
-                    kotlin.js().compilations.getByName("integrationTest")
-                ),
-                compilations.toSet()
-            )
-        }
-    }
-
-    private fun String.checkInferredSourceSetsVisibility(
-        vararg expectedVisibleSourceSets: String
-    ) = assertEquals(
-        expectedVisibleSourceSets.toSet(),
-        getVisibleSourceSetsFromAssociateCompilations(kotlin.sourceSets.getByName(this).internal.compilations).map { it.name }.toSet()
-    )
-
-    private fun KotlinSourceSet.checkInferredSourceSetsVisibility(
-        vararg expectedVisibleSourceSets: KotlinSourceSet
-    ) = assertEquals(
-        expectedVisibleSourceSets.map { it.name }.toSet(),
-        getVisibleSourceSetsFromAssociateCompilations(this.internal.compilations).map { it.name }.toSet()
-    )
-}