// Tests that methods of generic structs implementing generic interfaces
// are properly type-checked when the struct is instantiated indirectly
// (e.g. through a function that constructs the struct and returns it as
// the interface type). Previously, generic_insts_to_concrete() would
// register concrete types for these methods only after the checker's
// post_process_generic_fns loop had already finished, causing cgen to
// attempt code generation for unchecked AST nodes.

interface Processor[T] {
	process(val T) T
}

struct Doubler[T] {
	factor T
}

fn (d &Doubler[T]) process(val T) T {
	return val * d.factor
}

struct Negator[T] {
	offset T
}

fn (n &Negator[T]) process(val T) T {
	return -val + n.offset
}

fn make_doubler[T](factor T) Processor[T] {
	return Processor[T](&Doubler[T]{
		factor: factor
	})
}

fn make_negator[T](offset T) Processor[T] {
	return Processor[T](&Negator[T]{
		offset: offset
	})
}

struct Pipeline[T] {
mut:
	processors []Processor[T]
}

fn (mut p Pipeline[T]) add_doubler(factor T) {
	p.processors << make_doubler[T](factor)
}

fn (mut p Pipeline[T]) add_negator(offset T) {
	p.processors << make_negator[T](offset)
}

fn (p &Pipeline[T]) run(val T) T {
	mut result := val
	for proc in p.processors {
		result = proc.process(result)
	}
	return result
}

fn test_generic_interface_cross_module_recheck() {
	mut p := Pipeline[f64]{}
	// Only add_doubler is called; add_negator is never called.
	// But Negator[f64] still gets instantiated via generic_insts_to_concrete
	// and its process method must be properly type-checked.
	p.add_doubler(3.0)
	assert p.run(5.0) == 15.0
}