redef class AForExpr
	init init_aforexpr (
		n_kwfor: nullable TKwfor,
		n_groups: Collection[Object], # Should be Collection[AForGroup]
		n_kwdo: nullable TKwdo,
		n_block: nullable AExpr,
		n_label: nullable ALabel
	)
	do
		_n_kwfor = n_kwfor.as(not null)
		n_kwfor.parent = self
		self.n_groups.unsafe_add_all(n_groups)
		_n_kwdo = n_kwdo.as(not null)
		n_kwdo.parent = self
		_n_block = n_block
		if n_block != null then n_block.parent = self
		_n_label = n_label
		if n_label != null then n_label.parent = self
	end

	redef fun replace_child(old_child: ANode, new_child: nullable ANode)
	do
		if _n_kwfor == old_child then
			n_kwfor = new_child.as(TKwfor)
			return
		end
		if n_groups.replace_child(old_child, new_child) then return
		if _n_kwdo == old_child then
			n_kwdo = new_child.as(TKwdo)
			return
		end
		if _n_block == old_child then
			n_block = new_child.as(nullable AExpr)
			return
		end
		if _n_label == old_child then
			n_label = new_child.as(nullable ALabel)
			return
		end
	end

	redef fun n_kwfor=(node)
	do
		_n_kwfor = node
		node.parent = self
	end
	redef fun n_kwdo=(node)
	do
		_n_kwdo = node
		node.parent = self
	end
	redef fun n_block=(node)
	do
		_n_block = node
		if node != null then node.parent = self
	end
	redef fun n_label=(node)
	do
		_n_label = node
		if node != null then node.parent = self
	end


	redef fun visit_all(v: Visitor)
	do
		v.enter_visit(_n_kwfor)
		n_groups.visit_all(v)
		v.enter_visit(_n_kwdo)
		v.enter_visit(_n_block)
		v.enter_visit(_n_label)
	end
end

redef class AForExpr
	redef fun after_simple_misc(v)
	do
		v.check_do_expr(n_block)
	end
end

redef class AForExpr
	# The break escape mark associated with the 'for'
	var break_mark: nullable EscapeMark

	# The continue escape mark associated with the 'for'
	var continue_mark: nullable EscapeMark

	redef fun accept_scope_visitor(v)
	do
		for g in n_groups do
			v.enter_visit(g.n_expr)
		end

		# Protect automatic variables
		v.scopes.unshift(new Scope)

		for g in n_groups do
			# Create the automatic variables
			var variables = new Array[Variable]
			g.variables = variables
			for nid in g.n_ids do
				var va = new Variable(nid.text)
				v.register_variable(nid, va)
				variables.add(va)
			end
		end

		var escapemark = v.make_escape_mark(n_label, true)
		self.break_mark = escapemark
		self.continue_mark = escapemark.continue_mark
		v.enter_visit_block(n_block, escapemark)

		v.shift_scope
	end
end

redef class AForExpr
	super ADoBlockHelper

	redef fun loop_block do return self.n_block

	redef fun accept_forward_analysis(v) do
		for n_group in n_groups do
			v.enter_visit(n_group.n_expr)
		end
		accept_loop_forward_analysis(v)
	end
end

redef class AForExpr
	redef fun accept_flow_visitor(v)
	do
		for g in n_groups do
			v.enter_visit(g.n_expr)
		end

		var before_loop = v.make_sub_flow

		v.enter_visit(self.n_block)

		var after_block = v.current_flow_context

		before_loop.add_loop(after_block)
		v.merge_continues_to(before_loop, self.continue_mark)

		v.make_merge_flow(v.current_flow_context, before_loop)
		v.merge_breaks(self.break_mark)
	end
end

redef class AForExpr
	super ALoopHelper

	redef fun loop_block do return n_block
	redef fun loop_label do return n_label

	redef fun accept_pretty_printer(v) do
		var can_inline = v.can_inline(self)
		v.visit n_kwfor
		v.adds

		for n_group in n_groups do
			v.visit n_group
			if n_group != n_groups.last then v.add ", "

		end

		v.adds
		v.visit n_kwdo
		if can_inline then visit_loop_inline v else visit_loop_block v
	end
end

redef class AForExpr
	redef fun accept_reaching_defs(v) do
		# add variables from `for` declaration
		for n_group in n_groups do
			var variables = n_group.variables
			if variables == null then continue
			for variable in variables do v.gen(variable, n_group.location)
		end
		super
		# remove variables from `for` declaration
		for n_group in n_groups do
			var variables = n_group.variables
			if variables == null then continue
			for variable in variables do v.kill(variable)
		end
	end
end

redef class AForExpr
	redef fun accept_typing(v)
	do
		v.has_loop = true

		for g in n_groups do
			var mtype = v.visit_expr(g.n_expr)
			if mtype == null then return
			g.do_type_iterator(v, mtype)
			if g.is_broken then is_broken = true
		end

		v.visit_stmt(n_block)

		self.mtype = n_block.mtype
		self.is_typed = true
	end
end

redef class AForExpr
	redef fun stmt(v)
	do
		var iters = new Array[Instance]

		for g in n_groups do
			var col = v.expr(g.n_expr)
			if col == null then return
			if col.is_null then fatal(v, "Receiver is null")

			var iter = v.callsite(g.method_iterator, [col]).as(not null)
			iters.add iter
		end

		loop
			for g in n_groups, iter in iters do
				var isok = v.callsite(g.method_is_ok, [iter]).as(not null)
				if not isok.is_true then break label
				if g.variables.length == 1 then
					var item = v.callsite(g.method_item, [iter]).as(not null)
					#self.debug("item {item}")
					v.write_variable(g.variables.first, item)
				else if g.variables.length == 2 then
					var key = v.callsite(g.method_key, [iter]).as(not null)
					v.write_variable(g.variables[0], key)
					var item = v.callsite(g.method_item, [iter]).as(not null)
					v.write_variable(g.variables[1], item)
				else
					abort
				end
			end
			v.stmt(self.n_block)
			if v.is_escape(self.break_mark) then break
			v.is_escape(self.continue_mark) # Clear the break
			if v.is_escaping then break
			for g in n_groups, iter in iters do
				v.callsite(g.method_next, [iter])
			end
		end label
		for g in n_groups, iter in iters do
			var method_finish = g.method_finish
			if method_finish != null then
				v.callsite(method_finish, [iter])
			end
		end
	end
end

redef class AForExpr
	redef fun stmt(v)
	do
		for g in n_groups do
			var cl = v.expr(g.n_expr, null)
			var it_meth = g.method_iterator
			assert it_meth != null
			var it = v.compile_callsite(it_meth, [cl])
			assert it != null
			g.it = it
		end
		v.add("for(;;) \{")
		for g in n_groups do
			var it = g.it
			var isok_meth = g.method_is_ok
			assert isok_meth != null
			var ok = v.compile_callsite(isok_meth, [it])
			assert ok != null
			v.add("if(!{ok}) break;")
			if g.variables.length == 1 then
				var item_meth = g.method_item
				assert item_meth != null
				var i = v.compile_callsite(item_meth, [it])
				assert i != null
				v.assign(v.variable(g.variables.first), i)
			else if g.variables.length == 2 then
				var key_meth = g.method_key
				assert key_meth != null
				var i = v.compile_callsite(key_meth, [it])
				assert i != null
				v.assign(v.variable(g.variables[0]), i)
				var item_meth = g.method_item
				assert item_meth != null
				i = v.compile_callsite(item_meth, [it])
				assert i != null
				v.assign(v.variable(g.variables[1]), i)
			else
				abort
			end
		end
		v.stmt(self.n_block)
		v.add_escape_label(continue_mark)
		for g in n_groups do
			var next_meth = g.method_next
			assert next_meth != null
			v.compile_callsite(next_meth, [g.it])
		end
		v.add("\}")
		v.add_escape_label(break_mark)

		for g in n_groups do
			var method_finish = g.method_finish
			if method_finish != null then
				# TODO: Find a way to call this also in long escape (e.g. return)
				v.compile_callsite(method_finish, [g.it])
			end
		end
	end
end