n.X = cheapExpr(n.X, init)
	ptr, len := backingArrayPtrLen(n.X)
	return mkcall("slicebytetostring", n.Type(), init, a, ptr, len)
}

// walkBytesToStringTemp walks an OBYTES2STRTMP node.
func walkBytesToStringTemp(n *ir.ConvExpr, init *ir.Nodes) ir.Node {
	n.X = walkExpr(n.X, init)
	if !base.Flag.Cfg.Instrumenting {
		// Let the backend handle OBYTES2STRTMP directly
		// to avoid a function call to slicebytetostringtmp.

        )
    }

    @Test
    fun `Kotlin init scripts from init dir can add buildscript repositories to projects`() {

        val testRepositoryDir = file("test-repository").apply { mkdirs() }

        val guh = file("gradle-user-home").apply { mkdirs() }
        guh.withFolders {
            "init.d" {
                withFile(
                    "init.gradle.kts",
                    """

        exec().groovy               | "exec.init.gradle"
        javaexec().groovy           | "exec.init.gradle"
        processBuilder().groovy     | "exec.init.gradle"
        stringArrayExecute().groovy | "exec.init.gradle"
        runtimeExec().groovy        | "exec.init.gradle"
        exec().kotlin               | "exec.init.gradle.kts"
        javaexec().kotlin           | "exec.init.gradle.kts"

env GO111MODULE=on

# We should not create a go.mod file unless the user ran 'go mod init' explicitly.
# However, we should suggest 'go mod init' if we can find an alternate config file.
cd $WORK/test/x
! go list .
stderr 'found .git/config in .*[/\\]test'
stderr '\s*cd \.\. && go mod init'

# The command we suggested should succeed.
cd ..
go mod init
go list -m all
stdout '^m$'

import org.gradle.tooling.ProjectConnection

class BuildProgressCrossVersionSpec extends ToolingApiSpecification {
    def "generates init script operation when there are init scripts"() {
        file("init.gradle") << "println 'init'"

        when:
        def events = ProgressEvents.create()
        withConnection {
            ProjectConnection connection ->
                connection.newBuild()

			}
		}
	})
}

var Value_SwapTests = []struct {
	init any
	new  any
	want any
	err  any
}{
	{init: nil, new: nil, err: "sync/atomic: swap of nil value into Value"},
	{init: nil, new: true, want: nil, err: nil},
	{init: true, new: "", err: "sync/atomic: swap of inconsistently typed value into Value"},
	{init: true, new: false, want: true, err: nil},
}

func TestValue_Swap(t *testing.T) {

)


// declarations of init
const _, init /* ERROR "cannot declare init" */ , _ = 0, 1, 2
type init /* ERROR "cannot declare init" */ struct{}
var _, init /* ERROR "cannot declare init" */ int

func init() {}
func init /* ERROR "missing function body" */ ()

func _() { const init = 0 }
func _() { type init int }
func _() { var init int; _ = init }

// invalid array types
type (

        def init = gradleUserHomeDir.file("init.gradle.kts").tap {
            text = """
                initscript {
                    dependencies {
                        classpath(files("${escapeString(initJar)}"))
                    }
                }
            """.stripIndent()
        }

        def someInit = gradleUserHomeDir.file("init.d", "some.init.gradle.kts").tap {
            text = """

import "fmt"

func main() {}

func init() {
	var m = map[int]int{}
	var p *int

	defer func() {
		recover()
		check(1, len(m))
		check(42, m[2])
	}()
	m[2], *p = 42, 2
}

func init() {
	var m = map[int]int{}
	p := []int{}

	defer func() {
		recover()
		check(1, len(m))
		check(2, m[2])
	}()
	m[2], p[1] = 2, 2
}

func init() {
	type P struct{ i int }

        then:
        scripts.empty
    }

    def "locates each script from init.d directory"() {
        def scripts = []

        given:
        def script1 = distDir.createFile("init.d/script1.gradle")
        def script2 = distDir.createFile("init.d/script2.gradle")
        distDir.createFile("init.d/readme.txt")
        distDir.createFile("init.d/lib/test.jar")

        when:
        finder.findScripts(scripts)