redef fun expr(v)
	do
		var last = self.n_expr.last
		for e in self.n_expr do
			if e == last then break
			v.stmt(e)
		end
		return v.expr(last, null)
	end

	redef fun expr(v) do return v.frame.as(not null).arguments.first

	redef fun expr(v) do
		var res = v.new_var(self.mtype.as(not null))
		var cond = v.expr_bool(self.n_expr)
		v.add("if ({cond})\{")
		v.assign(res, v.expr(self.n_then.as(not null), null))
		v.add("\} else \{")
		v.assign(res, v.expr(self.n_else.as(not null), null))
		v.add("\}")
		return res
	end

	redef fun expr(v) do
		if value isa Int then
			return v.int_instance(self.value.as(Int))
		else if value isa Byte then
			return v.byte_instance(self.value.as(Byte))
		else
			# Should not happen
			abort
		end
	end

	redef fun expr(v) do return v.float_instance("{self.n_float.text}")

	redef fun expr(v) do return v.null_instance

	redef fun expr(v) do return v.expr(self.n_expr, null)

	redef fun expr(v) do
		var recv = v.expr(n_expr, null)
		var callsite = callsite.as(not null)
		var args = v.varargize(callsite.mpropdef, callsite.signaturemap, recv, raw_arguments)
		return v.compile_callsite(callsite, args)
	end

	redef fun expr(v)
	do
		var frame = v.frame
		assert frame != null
		var recv = frame.arguments.first

		var callsite = self.callsite
		if callsite != null then
			var args

			if self.n_args.n_exprs.is_empty then
				# Add automatic arguments for the super init call
				args = [recv]
				for i in [0..callsite.msignature.arity[ do
					args.add(frame.arguments[i+1])
				end
			else
				args = v.varargize(callsite.mpropdef, callsite.signaturemap, recv, self.n_args.n_exprs)
			end

			# Super init call
			var res = v.compile_callsite(callsite, args)
			return res
		end

		var mpropdef = self.mpropdef.as(not null)

		var args
		if self.n_args.n_exprs.is_empty then
			args = frame.arguments
		else
			args = v.varargize(mpropdef, signaturemap, recv, self.n_args.n_exprs)
		end

		# Standard call-next-method
		return v.supercall(mpropdef, recv.mtype.as(MClassType), args)
	end

	redef fun expr(v)
	do
		var mtype = self.recvtype
		assert mtype != null

		if mtype.mclass.name == "NativeArray" then
			# TODO handle native arrays
			v.info("NOT YET IMPLEMENTED new NativeArray")
		end

		var recv = v.init_instance(mtype)

		var callsite = self.callsite
		if callsite == null then return recv

		var args = v.varargize(callsite.mpropdef, callsite.signaturemap, recv, self.n_args.n_exprs)
		var res2 = v.compile_callsite(callsite, args)
		if res2 != null then
			return res2
		end
		return recv
	end

	redef fun expr(v) do
		return v.variable(self.variable.as(not null))
	end

	redef fun expr(v) do return v.frame.as(not null).arguments.first

	redef fun expr(v) do
		var cond = v.expr_bool(self.n_expr)
		return v.new_expr("!{cond}", self.mtype.as(not null))
	end

	redef fun expr(v) do return v.char_instance(self.value.as(not null))

	redef fun expr(v) do return v.bool_instance(true)

	redef fun expr(v) do return v.bool_instance(false)

	redef fun expr(v)
	do
		var i = v.expr(self.n_expr, null)
		var cast_type = self.cast_type
		if cast_type == null then return null # no-no on broken node
		return v.type_test(i, cast_type)
	end

	redef fun expr(v)
	do
		var i = v.expr(n_expr, null)
		v.add_cast(i, mtype.as(not null))
		return i
	end

	redef fun expr(v) do
		var i = v.expr(n_expr, null)
		if i.mtype.is_java_primitive then return i

		v.add("if ({i} == null || {i}.is_null()) \{")
		v.add_abort("Cast failed")
		v.add("\}")
		return i
	end

	redef fun expr(v) do
		var recv = v.expr(self.n_expr, null)
		var mproperty = self.mproperty.as(not null)
		return v.read_attribute(mproperty, recv)
	end

	redef fun expr(v) do
		var recv = v.expr(self.n_expr, null)
		var mproperty = self.mproperty.as(not null)
		return v.isset_attribute(mproperty, recv)
	end

	redef fun expr(v) do
		var variable = self.variable.as(not null)
		var i = v.expr(self.n_value, variable.declared_type)
		v.assign(v.variable(variable), i)
		return i
	end

	redef fun expr(v)
	do
		var res = v.new_var(self.mtype.as(not null))
		var i1 = v.expr(self.n_expr, null)
		v.add("if ({i1} != null && !{i1}.is_null()) \{")
		v.assign(res, i1)
		v.add("\} else \{")
		var i2 = v.expr(self.n_expr2, null)
		v.assign(res, i2)
		v.add("\}")
		return res
	end

	redef fun expr(v) do
		var recv = v.expr(self.n_expr, null)
		var i = v.expr(self.n_value, null)
		var mproperty = self.mproperty.as(not null)
		v.write_attribute(mproperty, recv, i)
		return i
	end

	redef fun expr(v) do
		var res = v.new_var(self.mtype.as(not null))
		var i1 = v.expr_bool(self.n_expr)
		v.add("if ({i1}) \{")
		v.add("{res} = true;")
		v.add("\} else \{")
		var i2 = v.expr_bool(self.n_expr2)
		v.add("{res} = {i2};")
		v.add("\}")
		return res
	end

	redef fun expr(v) do
		var res = v.new_var(mtype.as(not null))
		var i1 = v.expr_bool(n_expr)
		v.add("if (!{i1}) \{")
		v.add("{res} = true;")
		v.add("\} else \{")
		var i2 = v.expr_bool(n_expr2)
		v.add("{res} = {i2};")
		v.add("\}")
		return res
	end

	redef fun expr(v) do
		var res = v.new_var(self.mtype.as(not null))
		var i1 = v.expr_bool(self.n_expr)
		v.add("if (!{i1}) \{")
		v.add("{res} = false;")
		v.add("\} else \{")
		var i2 = v.expr_bool(self.n_expr2)
		v.add("{res} = {i2};")
		v.add("\}")
		return res
	end