}
	if typ.Kind() == types.TFUNC && typ.Recv() != nil {
		base.FatalfAt(pos, "misuse of method type: %v", typ)
	}
	types.CalcSize(typ)

	sym := &types.Sym{
		Name: autotmpname(len(curfn.Dcl)),
		Pkg:  types.LocalPkg,
	}
	name := curfn.NewLocal(pos, sym, typ)
	name.SetEsc(ir.EscNever)
	name.SetUsed(true)
	name.SetAutoTemp(true)

	return name
}

var (
	autotmpnamesmu sync.Mutex

        def evaluator = ******@****.***hema(model.settingsSequence, model.projectSequence)
        def settings = evaluator.evaluate("settings.gradle.dcl", file("settings.gradle.dcl").text)
        def project = evaluator.evaluate("build.gradle.dcl", file("build.gradle.dcl").text)

	sort.SliceStable(fn.Dcl, func(i, j int) bool {
		return cmpstackvarlt(fn.Dcl[i], fn.Dcl[j], mls)
	})

	if mls != nil {
		// Rewrite fn.Dcl to reposition followers (subsumed vars) to
		// be immediately following the leader var in their partition.
		followers := []*ir.Name{}
		newdcl := make([]*ir.Name, 0, len(fn.Dcl))
		for i := 0; i < len(fn.Dcl); i++ {
			n := fn.Dcl[i]
			if mls.Subsumed(n) {

        file("settings.gradle.dcl") << pluginsFromIncludedBuild

        file("build.gradle.dcl") << declarativeScriptThatConfiguresOnlyTestSoftwareType

        when:
        run(":printTestSoftwareTypeExtensionImplConfiguration")

        then:
        assertThatDeclaredValuesAreSetProperly()

        when:
        file("build.gradle.dcl") << """
            testSoftwareType {

        file("settings.gradle.dcl") << getDeclarativeSettingsScriptThatSetsConventions("""
            ${setFoo("")}
        """)
        file("settings.gradle.dcl") << """
            include("foo")
        """

        and: 'a build file that only specifies the software type'
        file("foo/build.gradle.dcl") << getDeclarativeScriptThatConfiguresOnlyTestSoftwareType()

        when:

                    }

                    currentPath.add(dcl)
                    if (dcl is KtClassOrObject) {
                        ktClasses.add(dcl)
                    }
                    super.visitDeclaration(dcl)
                    currentPath.removeLast()
                    if (dcl is KtClassOrObject) {
                        ktClasses.removeLast()
                    }

        file("b/build.gradle") << ""
        file("pluginIncluded/settings.gradle.dcl") << "rootProject.name = \"pluginIncluded\""

        expect:
        succeeds(":help", ":a:help", ":b:help")
        outputContains("name = test-value")
    }

    def 'schema is written during settings interpretation'() {
        given:
        file("settings.gradle.dcl") << """
            rootProject.name = "test"
        """

        when:

        given:
        settingsFile("""
            include(":sub")
        """)

        file("build.gradle.dcl") << ""

        file("sub/build.gradle.dcl") << ""

        when:
        run(":help")

        then:
        [
            file(".gradle/declarative-schema/project.dcl.schema"),
        ].every { it.isFile() && it.text != "" }
    }

 * * importing properties using the [org.gradle.api.provider.Property] API,
 * * importing types from functions that return or configure custom types.
 *
 * If object conversion is supported by the schema, also brings the basic DCL conversion capabilities
 * for resolving properties and member functions, see [conversionSupport]
 */
internal
fun EvaluationSchemaBuilder.gradleDslGeneralSchema() {

                }
            )
        }
    }

    private
    fun scriptContextFromFileName(fileName: String) = when (File(fileName).name) {
        "build.gradle.dcl" -> DeclarativeScriptContext.ProjectScript
        "settings.gradle.dcl" -> object : DeclarativeScriptContext.SettingsScript {}
        else -> DeclarativeScriptContext.UnknownScript
    }