// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Check for cycles in a pointer value's method call.

package ptrmethcall

type T int

func (*T) pm() int {
	_ = x
	return 0
}

var (
	p *T
	x = p.pm() // ERROR "initialization cycle|depends upon itself"

	// time. Since v is the first vertex we found within the cycle, any
	// vertices we visited earlier cannot be part of the cycle.
	for stack[0] != v {
		stack = stack[1:]
	}

	// TODO(mdempsky): Pivot stack so we report the cycle from the top?

	err := check.newError(InvalidInstanceCycle)
	obj0 := check.mono.vertices[v].obj
	err.addf(obj0, "instantiation cycle:")

	qf := RelativeTo(check.pkg)

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Check for cycles in a pointer literal's method call.

package ptrlitmethcall

type T int

func (*T) pm() int {
	_ = x
	return 0
}

// license that can be found in the LICENSE file.

// Check for cycles in the method call of a pointer value returned
// from a function call.

package funcptrmethcall

type T int

func (*T) pm() int {
	_ = x
	return 0
}

func pf() *T {
	return nil
}

	var cycle int
	return func() float64 {
		p := float64(cycle)/float64(period)*2*math.Pi + phase
		cycle++
		if cycle == period {
			cycle = 0
		}
		return math.Sin(p) * amp
	}
}

// ramp returns a stream that moves from zero to height
// over the course of length steps.
func ramp(height float64, length int) float64Stream {
	var cycle int
	return func() float64 {

// license that can be found in the LICENSE file.

// Check for cycles in the method call of a value returned from a function call.

package funcmethcall

type T int

func (T) m() int {
	_ = x
	return 0
}

func f() T {
	return T(0)
}

var (
	t T
	x = f().m() // ERROR "initialization cycle|depends upon itself"

// license that can be found in the LICENSE file.

// Check for cycles in the method call of an embedded struct returned
// from a function call.

package funcembedmethcall

type T int

func (T) m() int {
	_ = x
	return 0
}

func g() E {
	return E{0}
}

type E struct{ T }

var (
	e E
	x = g().m() // ERROR "initialization cycle|depends upon itself" 

            // Visiting dependencies -> have found a cycle
            CachingDirectedGraphWalker<TaskInternal, Void> graphWalker = new CachingDirectedGraphWalker<>((node, values, connectedNodes) -> visitDependenciesOf(node, connectedNodes::add));
            graphWalker.add(task);
            List<Set<TaskInternal>> cycles = graphWalker.findCycles();
            Set<TaskInternal> cycle = cycles.get(0);

	}
	cfg.MaxWait, err = time.ParseDuration(maxWait)
	if err != nil {
		return err
	}
	cycle := env.Get(EnvCycle, kvs.GetWithDefault(Cycle, DefaultKVS))
	if cycle == "" {
		cycle = "1m"
	}
	cfg.Cycle, err = time.ParseDuration(cycle)
	if err != nil {
		return err
	}
	return nil

    }

    def "detects cycles early"() {
        replacements.module("o:a").replacedBy("o:b")
        when: replacements.module("o:b").replacedBy("o:a")

        then:
        def ex = thrown(InvalidUserDataException)
        ex.message == "Cannot declare module replacement o:b->o:a because it introduces a cycle: o:b->o:a->o:b"
    }

    def "detects transitive cycles early"() {