redef class AForGroup
	init init_aforgroup (
		n_ids: Collection[Object], # Should be Collection[TId]
		n_kwin: nullable TKwin,
		n_expr: nullable AExpr
	)
	do
		self.n_ids.unsafe_add_all(n_ids)
		_n_kwin = n_kwin.as(not null)
		n_kwin.parent = self
		_n_expr = n_expr.as(not null)
		n_expr.parent = self
	end

	redef fun replace_child(old_child: ANode, new_child: nullable ANode)
	do
		if n_ids.replace_child(old_child, new_child) then return
		if _n_kwin == old_child then
			n_kwin = new_child.as(TKwin)
			return
		end
		if _n_expr == old_child then
			n_expr = new_child.as(AExpr)
			return
		end
	end

	redef fun n_kwin=(node)
	do
		_n_kwin = node
		node.parent = self
	end
	redef fun n_expr=(node)
	do
		_n_expr = node
		node.parent = self
	end


	redef fun visit_all(v: Visitor)
	do
		n_ids.visit_all(v)
		v.enter_visit(_n_kwin)
		v.enter_visit(_n_expr)
	end
end

redef class AForGroup
	redef fun after_simple_misc(v)
	do
		n_expr.warn_parentheses(v)
	end
end

redef class AForGroup
	# The automatic variables in order
	var variables: nullable Array[Variable]
end

redef class AForGroup
	redef fun accept_pretty_printer(v) do
		for n_id in n_ids do
			v.visit n_id
			if n_id != n_ids.last then v.add ", "
		end

		v.adds
		v.consume "in"
		v.adds
		v.visit n_expr
	end
end

redef class AForGroup
	var coltype: nullable MClassType

	var method_iterator: nullable CallSite
	var method_is_ok: nullable CallSite
	var method_item: nullable CallSite
	var method_next: nullable CallSite
	var method_key: nullable CallSite
	var method_finish: nullable CallSite

	var method_lt: nullable CallSite
	var method_successor: nullable CallSite

	private fun do_type_iterator(v: TypeVisitor, mtype: MType)
	do
		if mtype isa MNullType then
			v.error(self, "Type Error: `for` cannot iterate over `null`.")
			return
		end

		# get obj class
		var objcla = v.get_mclass(self, "Object")
		if objcla == null then return

		# check iterator method
		var itdef = v.build_callsite_by_name(self, mtype, "iterator", n_expr isa ASelfExpr)
		if itdef == null then
			v.error(self, "Type Error: `for` expects a type providing an `iterator` method, got `{mtype}`.")
			return
		end
		self.method_iterator = itdef

		# check that iterator return something
		var ittype = itdef.msignature.return_mtype
		if ittype == null then
			v.error(self, "Type Error: `for` expects the method `iterator` to return an `Iterator` or `MapIterator` type.")
			return
		end

		# get iterator type
		var colit_cla = v.try_get_mclass(self, "Iterator")
		var mapit_cla = v.try_get_mclass(self, "MapIterator")
		var is_col = false
		var is_map = false

		if colit_cla != null and v.is_subtype(ittype, colit_cla.get_mtype([objcla.mclass_type.as_nullable])) then
			# Iterator
			var coltype = ittype.supertype_to(v.mmodule, v.anchor, colit_cla)
			var variables =  self.variables
			if variables.length != 1 then
				v.error(self, "Type Error: `for` expects only one variable when using `Iterator`.")
			else
				variables.first.declared_type = coltype.arguments.first
			end
			is_col = true
		end

		if mapit_cla != null and v.is_subtype(ittype, mapit_cla.get_mtype([objcla.mclass_type.as_nullable, objcla.mclass_type.as_nullable])) then
			# Map Iterator
			var coltype = ittype.supertype_to(v.mmodule, v.anchor, mapit_cla)
			var variables = self.variables
			if variables.length != 2 then
				v.error(self, "Type Error: `for` expects two variables when using `MapIterator`.")
			else
				variables[0].declared_type = coltype.arguments[0]
				variables[1].declared_type = coltype.arguments[1]
			end
			is_map = true
		end

		if not is_col and not is_map then
			v.error(self, "Type Error: `for` expects the method `iterator` to return an `Iterator` or `MapIterator` type.")
			return
		end

		# anchor formal and virtual types
		if mtype.need_anchor then mtype = v.anchor_to(mtype)

		mtype = mtype.undecorate
		self.coltype = mtype.as(MClassType)

		# get methods is_ok, next, item
		var ikdef = v.build_callsite_by_name(self, ittype, "is_ok", false)
		if ikdef == null then
			v.error(self, "Type Error: `for` expects a method `is_ok` in type `{ittype}`.")
			return
		end
		self.method_is_ok = ikdef

		var itemdef = v.build_callsite_by_name(self, ittype, "item", false)
		if itemdef == null then
			v.error(self, "Type Error: `for` expects a method `item` in type `{ittype}`.")
			return
		end
		self.method_item = itemdef

		var nextdef = v.build_callsite_by_name(self, ittype, "next", false)
		if nextdef == null then
			v.error(self, "Type Error: `for` expects a method `next` in type {ittype}.")
			return
		end
		self.method_next = nextdef

		self.method_finish = v.try_build_callsite_by_name(self, ittype, "finish", false)

		if is_map then
			var keydef = v.build_callsite_by_name(self, ittype, "key", false)
			if keydef == null then
				v.error(self, "Type Error: `for` expects a method `key` in type `{ittype}`.")
				return
			end
			self.method_key = keydef
		end

		if self.variables.length == 1 and n_expr isa ARangeExpr then
			var variable = variables.first
			var vtype = variable.declared_type.as(not null)

			if n_expr isa AOrangeExpr then
				self.method_lt = v.build_callsite_by_name(self, vtype, "<", false)
			else
				self.method_lt = v.build_callsite_by_name(self, vtype, "<=", false)
			end

			self.method_successor = v.build_callsite_by_name(self, vtype, "successor", false)
		end
	end
end

redef class AForGroup
	redef fun accept_rapid_type_visitor(v)
	do
		v.add_callsite(self.method_iterator)
		v.add_callsite(self.method_is_ok)
		if self.variables.length == 1 then
			v.add_callsite(self.method_item)
		else if self.variables.length == 2 then
			v.add_callsite(self.method_key)
			v.add_callsite(self.method_item)
		else
			abort
		end
		v.add_callsite(self.method_next)
		var mf = self.method_finish
		if mf != null then v.add_callsite(mf)
	end
end

redef class AForGroup
	# C variable representing the iterator
	private var it: RuntimeVariable is noinit
end

redef class AForGroup
	private fun transform_in(v: TransformVisitor, before, begin, next, finish: AExpr, escapemark: EscapeMark)
	do
		var nexpr = n_expr

		# Shortcut on explicit range
		# Avoid the instantiation of the range and the iterator
		if self.variables.length == 1 and nexpr isa ARangeExpr and not v.phase.toolcontext.opt_no_shortcut_range.value then
			# Before: evaluate bounds
			var variable = variables.first
			before.add v.builder.make_var_assign(variable, nexpr.n_expr)
			var to = nexpr.n_expr2
			before.add to

			# Begin: check variable
			var is_ok = v.builder.make_call(v.builder.make_var_read(variable, variable.declared_type.as(not null)), method_lt.as(not null), [to.make_var_read])
			var nif = v.builder.make_if(is_ok, null)
			begin.add nif
			nif.n_else.add v.builder.make_break(escapemark)

			# Next: increment one
			var one = v.builder.make_int(1)
			var succ = v.builder.make_call(v.builder.make_var_read(variable, variable.declared_type.as(not null)), method_successor.as(not null), [one])
			next.add v.builder.make_var_assign(variable, succ)
			return
		end

		# Before: evaluate expr, make the iterator
		before.add nexpr
		var iter = v.builder.make_call(nexpr.make_var_read, method_iterator.as(not null), null)
		before.add iter

		# Begin: check iterator `is_ok`
		var is_ok = v.builder.make_call(iter.make_var_read, method_is_ok.as(not null), null)
		var nif = v.builder.make_if(is_ok, null)
		begin.add nif
		nif.n_else.add v.builder.make_break(escapemark)

		# Begin: assign automatic variables
		if variables.length == 1 then
			var item = v.builder.make_call(iter.make_var_read, method_item.as(not null), null)
			begin.add v.builder.make_var_assign(variables.first, item)
		else if variables.length == 2 then
			var key = v.builder.make_call(iter.make_var_read, method_key.as(not null), null)
			begin.add v.builder.make_var_assign(variables[0], key)
			var item = v.builder.make_call(iter.make_var_read, method_item.as(not null), null)
			begin.add v.builder.make_var_assign(variables[1], item)
		else
			abort
		end

		# Next: call next
		next.add v.builder.make_call(iter.make_var_read, method_next.as(not null), null)

		# Finish: call finish
		var method_finish = method_finish
		if method_finish != null then
			finish.add v.builder.make_call(iter.make_var_read, method_finish, null)
		end
	end
end

redef class AForGroup
	redef fun decorate_tag(v, res, token)
	do
		if not token isa TId then return null
		var vs = variables
		if vs == null then return null
		res.add_class("nc_v")
		var idx = n_ids.index_of(token)
		var variable = vs[idx]
		return variable.infobox(v)
	end
end