<xi:include href="/META-INF/extensions/compiler.xml"/>

  <extensionPoints>
    <extensionPoint
        qualifiedName="org.jetbrains.kotlin.declarationAttributeAltererExtension"
        interface="org.jetbrains.kotlin.extensions.DeclarationAttributeAltererExtension"
        area="IDEA_PROJECT"
    />

    <extensionPoint
        qualifiedName="org.jetbrains.kotlin.syntheticScopeProviderExtension"

    @Test
    fun `can download source distribution`() {

        withBuildScript(
            """

            val sourceDirs =
                ${SourceDistributionResolver::class.qualifiedName}(project).run {
                    sourceDirs()
                }

            require(sourceDirs.isNotEmpty()) {
                "Expected source directories but got none"
            }

            if (index == 0) {
                val qualifiedName = when (parent) {
                    is KaClassLikeSymbol -> parent.classId?.toString()
                    is KaCallableSymbol -> parent.callableId?.toString()
                    else -> null
                }

                if (qualifiedName != null) {
                    chunks += qualifiedName
                    continue
                }
            }

        resolutionContainer.data(node).let { resolution ->
            resolution is ConfiguringElementResolved &&
                resolution.elementType.name.qualifiedName == ConventionsConfiguringBlock::class.qualifiedName
        }

        }
    }

    private fun render(symbol: KaSymbol): String {
        val qualifiedName = when (symbol) {
            is KaCallableSymbol -> symbol.callableId?.toString()
            is KaClassLikeSymbol -> symbol.classId?.toString()
            else -> null
        }

        return qualifiedName ?: (symbol as? KaNamedSymbol)?.name?.asString() ?: "Unnamed"
    }

        }
    }

    val targetType by lazy {
        when (scriptType) {
            KotlinScriptType.PROJECT -> Project::class.qualifiedName
            KotlinScriptType.SETTINGS -> Settings::class.qualifiedName
            KotlinScriptType.INIT -> Gradle::class.qualifiedName
        }
    }

    val scriptType
        get() = scriptTypeMatch.scriptType

    private
    val scriptExtension

 * TODO: maybe "reify" the TAPI proxies to ensure equality?
 */
private
fun sameType(left: DataType, right: DataType) = when (left) {
    is DataClass -> right is DataClass && left.name.qualifiedName == right.name.qualifiedName
    is DataType.BooleanDataType -> right is DataType.BooleanDataType
    is DataType.IntDataType -> right is DataType.IntDataType
    is DataType.LongDataType -> right is DataType.LongDataType

	},
	"dns1035Label": {
		Name:         "DNS1035Label",
		ValidateFunc: func(s string) []string { return apimachineryvalidation.NameIsDNS1035Label(s, false) },
		MaxRegexSize: 30,
	},
	"qualifiedName": {
		Name:         "QualifiedName",
		ValidateFunc: validation.IsQualifiedName,
		MaxRegexSize: 60, // uses subdomain regex
	},

	"dns1123LabelPrefix": {
		Name:         "DNS1123LabelPrefix",

            samWithReceiver.annotation(HasImplicitReceiver::class.qualifiedName!!)
        }

        plugins.apply(AssignmentSubplugin::class.java)
        extensions.configure(AssignmentExtension::class.java) { assignment ->
            assignment.annotation(SupportsKotlinAssignmentOverloading::class.qualifiedName!!)
        }

        kotlinDslPluginOptions {

		},
		{
			name:        "qualifiedName",
			expr:        `format.qualifiedName().validate("contains a space")`,