redef class AWhileExpr
	init init_awhileexpr (
		n_kwwhile: nullable TKwwhile,
		n_expr: nullable AExpr,
		n_kwdo: nullable TKwdo,
		n_block: nullable AExpr,
		n_label: nullable ALabel
	)
	do
		_n_kwwhile = n_kwwhile.as(not null)
		n_kwwhile.parent = self
		_n_expr = n_expr.as(not null)
		n_expr.parent = self
		_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_kwwhile == old_child then
			n_kwwhile = new_child.as(TKwwhile)
			return
		end
		if _n_expr == old_child then
			n_expr = new_child.as(AExpr)
			return
		end
		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_kwwhile=(node)
	do
		_n_kwwhile = node
		node.parent = self
	end
	redef fun n_expr=(node)
	do
		_n_expr = 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_kwwhile)
		v.enter_visit(_n_expr)
		v.enter_visit(_n_kwdo)
		v.enter_visit(_n_block)
		v.enter_visit(_n_label)
	end
end

redef class AWhileExpr
	redef fun after_simple_misc(v)
	do
		if n_expr isa ATrueExpr then
			v.warning(self, "loop", "Warning: use `loop` instead of `while true do`.")
		else
			n_expr.warn_parentheses(v)
		end
		v.check_do_expr(n_block)
	end
end

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

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

	redef fun accept_scope_visitor(v)
	do
		var escapemark = v.make_escape_mark(n_label, true)
		self.break_mark = escapemark
		self.continue_mark = escapemark.continue_mark
		v.enter_visit(n_expr)
		v.enter_visit_block(n_block, escapemark)
	end
end

redef class AWhileExpr
	super ADoBlockHelper

	redef fun loop_block do return self.n_block

	redef fun accept_forward_analysis(v) do
		v.enter_visit(n_expr)
		accept_loop_forward_analysis(v)
	end
end

redef class AWhileExpr
	redef fun accept_flow_visitor(v)
	do
		var before_loop = v.make_sub_flow

		var after_expr = v.visit_expr(self.n_expr)

		v.current_flow_context = after_expr.when_true
		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.current_flow_context = after_expr.when_false
		v.merge_breaks(self.break_mark)
	end
end

redef class AWhileExpr
	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_kwwhile
		v.adds
		v.visit n_expr
		v.adds
		v.visit n_kwdo
		if can_inline then visit_loop_inline v else visit_loop_block v
	end
end

redef class AWhileExpr
	redef fun accept_typing(v)
	do
		v.has_loop = true
		v.visit_expr_bool(n_expr)
		v.visit_stmt(n_block)
		self.is_typed = true
	end
end

redef class AWhileExpr
	redef fun stmt(v)
	do
		loop
			var cond = v.expr(self.n_expr)
			if cond == null then return
			if not cond.is_true then return
			v.stmt(self.n_block)
			if v.is_escape(self.break_mark) then return
			v.is_escape(self.continue_mark) # Clear the break
			if v.is_escaping then return
		end
	end
end

redef class AWhileExpr
	redef fun stmt(v)
	do
		v.add("for(;;) \{")
		var cond = v.expr_bool(self.n_expr)
		v.add("if (!{cond}) break;")
		v.stmt(self.n_block)
		v.add_escape_label(continue_mark)
		v.add("\}")
		v.add_escape_label(break_mark)
	end
end

redef class AWhileExpr
	redef fun generate_basic_blocks(ssa, old_block)
	do
		old_block.last = self

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

		old_block.link(block)

		self.n_expr.generate_basic_blocks(ssa, old_block)
		self.n_block.generate_basic_blocks(ssa, block)

		# Link the inside of the block to the previous block
		block.link_special(old_block)

		# Create a new Block after the while
		var new_block = new BasicBlock
		new_block.first = self
		new_block.last = self
		new_block.need_update = true

		old_block.link_special(new_block)

		return new_block
	end
end

redef class AWhileExpr
	redef fun numbering(v, position)
	do
		return v.numbering(self.n_block, position)
	end
end

redef class AWhileExpr
	redef fun accept_transform_visitor(v)
	do
		var nloop = v.builder.make_loop
		var nif = v.builder.make_if(n_expr, null)
		nloop.add nif

		var nblock = n_block
		if nblock != null then nif.n_then.add nblock

		var escapemark = self.break_mark.as(not null)
		var nbreak = v.builder.make_break(escapemark)
		nif.n_else.add nbreak

		nloop.break_mark = self.break_mark
		nloop.continue_mark = self.continue_mark

		replace_with(nloop)
	end
end

redef class AWhileExpr
	redef fun stmt(v)
	do
		v.add_escape_label(break_mark)
		v.add_escape_label(continue_mark)
		v.add("for(;;) \{")
		var cond = v.expr_bool(self.n_expr)
		v.add("if (!{cond}) break;")
		v.stmt(self.n_block)
		v.add("\}")
	end
end