}

        @Override
        public void visitRoot(TypeMetadata typeMetadata, TypeToken<?> value) {
        }

        @Override
        public void visitNested(TypeMetadata typeMetadata, String qualifiedName, PropertyMetadata propertyMetadata, TypeToken<?> value) {
            propertyMetadata.getAnnotation(SoftwareType.class).ifPresent(softwareType -> {

    getByName(name).let {
        it as? T
            ?: throw IllegalStateException(
                "Element '$name' of type '${it::class.java.name}' from container '$this' cannot be cast to '${T::class.qualifiedName}'."
            )
    }


/**
 * Delegated property getter that locates extensions.
 */
inline operator fun <reified T : Any> ExtensionContainer.getValue(thisRef: Any?, property: KProperty<*>): T =

            extFunctions,
            extObjects,
            defaultImports.toSet()
        )
    }

    private
    val KClass<*>.fqName
        get() = DefaultFqName.parse(qualifiedName!!)

    class PreIndex {
        private
        val properties = mutableMapOf<KClass<*>, MutableMap<String, DataProperty>>()

        private

            assertTaskExecuted(
                ":consumer:generateExternalPluginSpecBuilders"
            )
        }
    }

    private
    inline fun <reified T> nameOf() = T::class.qualifiedName

    @Test
    fun `accessors are available after renaming precompiled script plugin from project dependency`() {

        withSettings(
            """
            $defaultSettingsScript

        }

        fun reference(type: Class<*>) {
            reference(type.name)
        }

        fun reference(type: KClass<*>) {
            reference(type.qualifiedName!!)
        }

        fun message(message: StructuredMessage) {
            fragments.addAll(message.fragments)
        }
    }
}


sealed class PropertyTrace {

            assertTrue(
                api.type<PluginCollection<*>>().functions
                    .filter { it.name == "matching" }
                    .single { it.parameters.single().type.sourceName == Spec::class.qualifiedName }
                    .parameters.single().type.type!!.isSAM
            )

            assertTrue(api.type<Spec<*>>().isSAM)
        }
    }

    private

            val fqn = when (val ref = function.dataClass) {
                is DataTypeRef.Name -> ref.fqName.toString()
                is DataTypeRef.Type -> (ref.dataType as? DataClass)?.name?.qualifiedName
                    ?: ref.dataType.toString()
            }
            append(fqn)
            append(".")
        }
        append(function.simpleName)
        append("#")

func ValidateAnnotations(annotations map[string]string, fldPath *field.Path) field.ErrorList {
	allErrs := field.ErrorList{}
	for k := range annotations {
		// The rule is QualifiedName except that case doesn't matter, so convert to lowercase before checking.
		for _, msg := range validation.IsQualifiedName(strings.ToLower(k)) {
			allErrs = append(allErrs, field.Invalid(fldPath, k, msg))
		}
	}

            publicClass("ConventionReceiver")
            publicInterface("Entry")
            publicInterface("Element", "Entry")
            publicInterface("CustomTask", Task::class.qualifiedName!!)
        }
        withClassLoaderFor(defaultPackageTypes) {
            val entryType = schemaTypeFor("Entry")
            val schema =
                TypedProjectSchema(

        is KaFirNamedClassOrObjectSymbol -> firSymbol.fir
        is KaFirPsiJavaClassSymbol -> firSymbol.fir
        is KaFirAnonymousObjectSymbol -> firSymbol.fir
        else -> error(
            "`${this::class.qualifiedName}` needs to be specially handled by the scope provider or is an unknown" +
                    " ${KaSymbolWithDeclarations::class.simpleName} implementation."
        )
    }