# `var x = y` is replaced with `x = y`
	#
	# Declarations are only useful for scope rules
	# Once names are associated with real objects, ther declaration become useless
	# Therefore, if there is no initial value, then just ignore it
	# Else, replace it with a simple assignment
	redef fun accept_transform_visitor(v)
	do
		var nexpr = n_expr
		if nexpr == null then
			# do nothing
			# note: not detached because the collection is currently under iteration
		else
			var nvar = v.builder.make_var_assign(self.variable.as(not null), nexpr)
			replace_with(nvar)
		end
	end

	# is replaced with `AIfExpr`
	# Expression if and statement-if use two distinct classes for historical reasons
	# However, on can replace the `AIfexprExpr` with the simpler `AIfExpr`
	redef fun accept_transform_visitor(v)
	do
		var nif = v.builder.make_if(n_expr, self.mtype)
		nif.n_then.add(n_then)
		nif.n_else.add(n_else)

		replace_with(nif)
	end

	# `(x)` is replaced with `x`
	redef fun accept_transform_visitor(v)
	do
		replace_with(n_expr)
	end

	# 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

	# `[x..y]` is replaced with `new Range[X](x,y)`
	redef fun accept_transform_visitor(v)
	do
		if parent isa AForGroup then return # to permit shortcut ranges
		replace_with(v.builder.make_new(init_callsite.as(not null), [n_expr, n_expr2]))
	end

	# `[x..y[` is replaced with `new Range[X].without_last(x,y)`
	redef fun accept_transform_visitor(v)
	do
		if parent isa AForGroup then return # to permit shortcut ranges
		replace_with(v.builder.make_new(init_callsite.as(not null), [n_expr, n_expr2]))
	end

	# `v += z` is replaced with `v = v + z`
	redef fun accept_transform_visitor(v)
	do
		var variable = self.variable.as(not null)

		var nread = v.builder.make_var_read(variable, read_type.as(not null))

		var nnewvalue = v.builder.make_call(nread, reassign_callsite.as(not null), [n_value])
		var nwrite = v.builder.make_var_assign(variable, nnewvalue)

		replace_with(nwrite)
	end

	# `x.foo(y)+=z` is replaced with
	#
	# ~~~nitish
	# x.foo(y) = x.foo(y) + z
	# ~~~
	#
	# witch is, in reality:
	#
	# ~~~nitish
	# x."foo="(y, x.foo(y)."+"(z))
	# ~~~
	redef fun accept_transform_visitor(v)
	do
		var nblock = v.builder.make_block
		nblock.add(n_expr)

		var read_args = new Array[AExpr]
		var write_args = new Array[AExpr]
		for a in raw_arguments do
			nblock.add(a)
			read_args.add(a.make_var_read)
			write_args.add(a.make_var_read)
		end

		var nread = v.builder.make_call(n_expr.make_var_read, callsite.as(not null), read_args)

		var nnewvalue = v.builder.make_call(nread, reassign_callsite.as(not null), [n_value])

		write_args.add(nnewvalue)
		var nwrite = v.builder.make_call(n_expr.make_var_read, write_callsite.as(not null), write_args)
		nblock.add(nwrite)

		replace_with(nblock)
	end

	# `x.a += z` is replaced with `x.a = x.a + z`
	redef fun accept_transform_visitor(v)
	do
		var nblock = v.builder.make_block
		nblock.add(n_expr)
		var attribute = self.mproperty.as(not null)

		var nread = v.builder.make_attr_read(n_expr.make_var_read, attribute)
		var nnewvalue = v.builder.make_call(nread, reassign_callsite.as(not null), [n_value])
		var nwrite = v.builder.make_attr_assign(n_expr.make_var_read, attribute, nnewvalue)
		nblock.add(nwrite)

		replace_with(nblock)
	end

	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

	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

	# `x or y` is replaced with `if x then x else y`
	redef fun accept_transform_visitor(v)
	do
		var nif = v.builder.make_if(n_expr, self.mtype)
		nif.n_then.add(n_expr.make_var_read)
		nif.n_else.add(n_expr2)

		replace_with(nif)
	end

	redef fun accept_transform_visitor(v)
	do
		# TODO
	end

	# `x and y` is replaced with `if x then y else x`
	redef fun accept_transform_visitor(v)
	do
		var nif = v.builder.make_if(n_expr, self.mtype)
		nif.n_then.add(n_expr2)
		nif.n_else.add(n_expr.make_var_read)

		replace_with(nif)
	end