// Copyright 2024 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

//go:build goexperiment.rangefunc && !windows

package main

/*
#include <stdint.h> // for uintptr_t

void go_callback_coro(uintptr_t handle);

static void call_go(uintptr_t handle) {
	go_callback_coro(handle);
}
*/
import "C"

import (
	"fmt"
	"iter"

// but an atomic list hanging off:
//
//		g._defer => d4 -> d3 -> drangefunc -> d2 -> d1 -> nil
//	                             | .head
//	                             |
//	                             +--> dY -> dX -> nil
//
// with each -> indicating a d.link pointer, and where drangefunc
// has the d.rangefunc = true bit set.
// Note that the function being ranged over may have added

	testFiles(t, []string{"p.go"}, [][]byte{[]byte(src)}, false, withSizes(&StdSizes{4, 4}))
}

func TestCheck(t *testing.T) {
	old := buildcfg.Experiment.RangeFunc
	defer func() {
		buildcfg.Experiment.RangeFunc = old
	}()
	buildcfg.Experiment.RangeFunc = true

	DefPredeclaredTestFuncs()
	testDirFiles(t, "../../internal/types/testdata/check", false)
}

// run -goexperiment rangefunc

// Copyright 2023 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Test the 'for range' construct ranging over functions.

package main

var gj int

func yield4x(yield func() bool) {
	_ = yield() && yield() && yield() && yield()
}

func yield4(yield func(int) bool) {

}

type State int

// Rewrite rewrites all the range-over-funcs in the files.
// It returns the set of function literals generated from rangefunc loop bodies.
// This allows for rangefunc loop bodies to be distingushed by debuggers.
func Rewrite(pkg *types2.Package, info *types2.Info, files []*syntax.File) map[*syntax.FuncLit]bool {
	ri := make(map[*syntax.FuncLit]bool)

		cmd = testenv.CleanCmdEnv(cmd)

		// Add the rangefunc GOEXPERIMENT unconditionally since some tests depend on it.
		// TODO(61405): Remove this once it's enabled by default.
		edited := false
		for i := range cmd.Env {
			e := cmd.Env[i]
			if _, vars, ok := strings.Cut(e, "GOEXPERIMENT="); ok {
				cmd.Env[i] = "GOEXPERIMENT=" + vars + ",rangefunc"
				edited = true
			}
		}
		if !edited {

// runoutput -goexperiment rangefunc

// Copyright 2023 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Torture test for range-over-func.
//
// cmd/internal/testdir runs this like
//
//	go run rangegen.go >x.go
//	go run x.go
//
// but a longer version can be run using
//
//	go run rangegen.go long
//

// we only need to pass one.
func ifaceeq(tab *uintptr, x, y unsafe.Pointer) (ret bool)
func efaceeq(typ *uintptr, x, y unsafe.Pointer) (ret bool)

// panic for various rangefunc iterator errors
func panicrangestate(state int)

// defer in range over func
func deferrangefunc() interface{}

func rand32() uint32

// *byte is really *runtime.Type

// and for heap defers, marked.
type _defer struct {
	heap      bool
	rangefunc bool    // true for rangefunc list
	sp        uintptr // sp at time of defer
	pc        uintptr // pc at time of defer
	fn        func()  // can be nil for open-coded defers
	link      *_defer // next defer on G; can point to either heap or stack!

	// If rangefunc is true, *head is the head of the atomic linked list

				pkg:      "crypto/x509",
			})
	}

	// GOEXPERIMENT=rangefunc tests
	if !t.compileOnly {
		for _, pkg := range []string{"iter", "slices", "maps"} {
			t.registerTest("GOEXPERIMENT=rangefunc",
				&goTest{
					variant: pkg,
					short:   t.short,
					env:     []string{"GOEXPERIMENT=rangefunc"},
					pkg:     pkg,
				})
		}
	}