if (descriptor is DeserializedSimpleFunctionDescriptor) return

        analyzeNextIfInline(descriptor)

        if (descriptor is PropertyDescriptor) {
            for (accessor in descriptor.accessors) {
                analyzeNextIfInline(accessor)
            }
        }
    }

    private fun analyzeNextIfInline(descriptor: CallableDescriptor) {

    fun conventions(conventions: ConventionsConfiguringBlock.() -> Unit)
}


/**
 * A receiver for the conventions block.  Note that this class is only used to provide a receiver for custom accessors
 * that expose the software types available in the build.
 */

        objects
            .newInstance<PluginDependenciesSpecScopeInternalServices>()
            .dependenciesAccessors.createPluginsBlockFactories(objects)
    }

    /**
     * Used by version catalog accessors in project scripts plugins {} block.
     */
    @Suppress("UNUSED")
    fun versionCatalogForPluginsBlock(name: String): ExternalModuleDependencyFactory =
        versionCatalogForPluginBlockFactories.getValue(name)
}

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.kotlin.dsl.accessors

import org.gradle.kotlin.dsl.fixtures.AbstractKotlinIntegrationTest

import org.hamcrest.CoreMatchers.containsString
import org.hamcrest.MatcherAssert.assertThat

import org.junit.Test

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

import gradlebuild.basics.accessors.kotlinMainSourceSet
import gradlebuild.basics.kotlindsl.configureKotlinCompilerForGradleBuild
import org.gradle.api.internal.initialization.DefaultClassLoaderScope
import org.jetbrains.kotlin.gradle.tasks.KotlinCompile

 */

package org.gradle.integtests.resolve.typesafe

class TypeSafeRootProjectAccessorsIntegrationTest extends AbstractTypeSafeProjectAccessorsIntegrationTest {
    def "generates type-safe accessors for a root project with name = #root)"() {
        given:
        settingsFile << """
            rootProject.name = '$root'
        """
        buildFile << """
            def projectDependency = projects.${accessor}

internal
class ScriptHandlerScopeInternal(
    private val scriptTarget: ExtensionAware,
    scriptHandler: ScriptHandler,
) : ScriptHandlerScope(scriptHandler) {

    /**
     * Used by version catalog accessors in project scripts plugins {} block.
     */
    @Suppress("UNUSED")
    fun versionCatalogExtension(name: String): ExternalModuleDependencyFactory =
        scriptTarget.extensions[name] as ExternalModuleDependencyFactory

import org.gradle.api.file.DirectoryProperty
import org.gradle.api.tasks.CacheableTask
import org.gradle.api.tasks.OutputDirectory
import org.gradle.api.tasks.TaskAction

import org.gradle.kotlin.dsl.accessors.writeSourceCodeForPluginSpecBuildersFor

import java.io.File


@CacheableTask
abstract class GenerateExternalPluginSpecBuilders : ClassPathSensitiveCodeGenerationTask(), SharedAccessorsPackageAware {

package org.gradle.kotlin.dsl.accessors

import org.junit.Assert.assertTrue
import org.gradle.internal.classpath.ClassPath

import org.hamcrest.CoreMatchers.*
import org.hamcrest.MatcherAssert.assertThat

import org.junit.Test


internal
interface InternalType


class TypeAccessibilityProviderTest : TestWithClassPath() {

    @Test
    fun `public generic type with primitive component type is accessible`() {

package org.gradle.kotlin.dsl.accessors

import org.gradle.api.reflect.TypeOf.typeOf

import org.gradle.kotlin.dsl.typeOf

import org.hamcrest.CoreMatchers.equalTo
import org.hamcrest.MatcherAssert.assertThat
import org.junit.Test


class KotlinTypeStringTest {

    @Test
    fun `#kotlinTypeStringFor array type`() {
        assertThat(
            kotlinTypeStringFor(typeOf<Array<String>>()),
            equalTo("Array<String>")