redef class AWithExpr
	init init_awithexpr (
		n_kwwith: nullable TKwwith,
		n_expr: nullable AExpr,
		n_kwdo: nullable TKwdo,
		n_block: nullable AExpr,
		n_label: nullable ALabel
	)
	do
		_n_kwwith = n_kwwith.as(not null)
		n_kwwith.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_kwwith == old_child then
			n_kwwith = new_child.as(TKwwith)
			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_kwwith=(node)
	do
		_n_kwwith = 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_kwwith)
		v.enter_visit(_n_expr)
		v.enter_visit(_n_kwdo)
		v.enter_visit(_n_block)
		v.enter_visit(_n_label)
	end
end

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

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

	redef fun accept_scope_visitor(v)
	do
		v.scopes.unshift(new Scope)

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

		v.enter_visit(n_expr)
		v.enter_visit_block(n_block, escapemark)

		v.shift_scope
	end
end

redef class AWithExpr
	redef fun accept_flow_visitor(v)
	do
		super
		v.merge_breaks(self.break_mark)
	end
end

redef class AWithExpr
	var method_start: nullable CallSite
	var method_finish: nullable CallSite

	redef fun accept_typing(v: TypeVisitor)
	do
		var mtype = v.visit_expr(n_expr)
		if mtype == null then return

		method_start = v.build_callsite_by_name(self, mtype, "start", n_expr isa ASelfExpr)
		method_finish = v.build_callsite_by_name(self, mtype, "finish", n_expr isa ASelfExpr)

		v.visit_stmt(n_block)
		self.mtype = n_block.mtype
		self.is_typed = true
	end
end

redef class AWithExpr
	redef fun stmt(v)
	do
		var expr = v.expr(self.n_expr)
		if expr == null then return

		v.callsite(method_start, [expr])
		v.stmt(self.n_block)
		v.is_escape(self.break_mark) # Clear the break

		# Execute the finally without an escape
		var old_mark = v.escapemark
		v.escapemark = null
		v.callsite(method_finish, [expr])
		# Restore the escape unless another escape was provided
		if v.escapemark == null then v.escapemark = old_mark
	end
end

redef class AWithExpr
	# is replaced with a do/end and injected calls to `start` and `finish`
	#
	# Basically, the following
	#
	# ~~~nitish
	# with expr do
	#   block
	# end label l
	# ~~~
	#
	# is transformed into
	#
	# ~~~nitish
	# var x = expr
	# do
	#   x.start
	#   block
	# end label l
	# x.finish
	# ~~~
	#
	# The point is that `finish` is called even if the block is escaped.
	redef fun accept_transform_visitor(v)
	do
		var escapemark = self.break_mark
		assert escapemark != null

		var nblock = v.builder.make_block

		var nexpr = n_expr

		nblock.add nexpr

		var ndo = v.builder.make_do
		ndo.break_mark = escapemark

		var start = v.builder.make_call(nexpr.make_var_read, method_start.as(not null), null)

		ndo.add start

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

		nblock.add ndo

		nblock.add v.builder.make_call(nexpr.make_var_read, method_finish.as(not null), null)

		replace_with(nblock)
	end
end