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 generate_basic_blocks(ssa, old_block)
	do
		old_block.last = self

		# The beginning of the block is the first instruction
		var block = new BasicBlock
		block.first = self.n_groups.first.n_expr
		block.last = self.n_block.as(not null)

		for g in n_groups do
			# Visit the test of the if
			g.n_expr.generate_basic_blocks(ssa, block)

			# Collect the variables declared in the for
			for v in g.variables do
				ssa.propdef.variables.add(v)
			end
		end

		old_block.link(block)

		block.link(old_block)

		var new_block = new BasicBlock
		new_block.first = self
		new_block.last = self

		new_block.need_update = true

		return new_block
	end
end

redef class AForExpr
	redef fun numbering(v, position)
	do
		for g in n_groups do
			# Give a position to each variable declared in the header of the for
			if g.variables.length == 1 then
				g.variables.first.position = position
				g.variables[0].position = position
				position += 1
			else if g.variables.length == 2 then
				g.variables[0].position = position
				position += 1
				g.variables[1].position = position
				position += 1
			end
			position = v.numbering(self.n_block, position)
		end
		return position
	end
end

redef class AForExpr
	redef fun accept_transform_visitor(v)
	do
		var escapemark = self.break_mark
		assert escapemark != null

		# Main block that will contain the whole for and will replace `self`
		var nblock = v.builder.make_block

		# Part before the loop
		var before = v.builder.make_block
		nblock.add before

		# The loop
		var nloop = v.builder.make_loop
		nloop.break_mark = escapemark
		nblock.add nloop

		# Part before the body inside the loop
		var begin = v.builder.make_block
		nloop.add begin

		# The `do` block with then user code
		var ndo = v.builder.make_do
		ndo.break_mark = escapemark.continue_mark
		nloop.add ndo

		ndo.add self.n_block.as(not null)

		# Fill up each part
		for g in n_groups do
			g.transform_in(v, before, begin, nloop, nblock, escapemark)
		end

		replace_with(nblock)
	end
end