redef class AIfExpr
	init init_aifexpr (
		n_kwif: nullable TKwif,
		n_expr: nullable AExpr,
		n_kwthen: nullable TKwthen,
		n_then: nullable AExpr,
		n_kwelse: nullable TKwelse,
		n_else: nullable AExpr
	)
	do
		_n_kwif = n_kwif.as(not null)
		n_kwif.parent = self
		_n_expr = n_expr.as(not null)
		n_expr.parent = self
		_n_kwthen = n_kwthen.as(not null)
		n_kwthen.parent = self
		_n_then = n_then
		if n_then != null then n_then.parent = self
		_n_kwelse = n_kwelse
		if n_kwelse != null then n_kwelse.parent = self
		_n_else = n_else
		if n_else != null then n_else.parent = self
	end

	redef fun replace_child(old_child: ANode, new_child: nullable ANode)
	do
		if _n_kwif == old_child then
			n_kwif = new_child.as(TKwif)
			return
		end
		if _n_expr == old_child then
			n_expr = new_child.as(AExpr)
			return
		end
		if _n_kwthen == old_child then
			n_kwthen = new_child.as(TKwthen)
			return
		end
		if _n_then == old_child then
			n_then = new_child.as(nullable AExpr)
			return
		end
		if _n_kwelse == old_child then
			n_kwelse = new_child.as(nullable TKwelse)
			return
		end
		if _n_else == old_child then
			n_else = new_child.as(nullable AExpr)
			return
		end
	end

	redef fun n_kwif=(node)
	do
		_n_kwif = node
		node.parent = self
	end
	redef fun n_expr=(node)
	do
		_n_expr = node
		node.parent = self
	end
	redef fun n_kwthen=(node)
	do
		_n_kwthen = node
		node.parent = self
	end
	redef fun n_then=(node)
	do
		_n_then = node
		if node != null then node.parent = self
	end
	redef fun n_kwelse=(node)
	do
		_n_kwelse = node
		if node != null then node.parent = self
	end
	redef fun n_else=(node)
	do
		_n_else = node
		if node != null then node.parent = self
	end


	redef fun visit_all(v: Visitor)
	do
		v.enter_visit(_n_kwif)
		v.enter_visit(_n_expr)
		v.enter_visit(_n_kwthen)
		v.enter_visit(_n_then)
		v.enter_visit(_n_kwelse)
		v.enter_visit(_n_else)
	end
end

redef class AIfExpr
	redef fun after_simple_misc(v)
	do
		n_expr.warn_parentheses(v)
	end
end

redef class AIfExpr

	# Merge flow on if .. else constructs.
	redef fun accept_forward_analysis(v) do
		v.enter_visit(n_expr)
		var inset = v.current_inset
		var outset = v.current_outset

		if n_then != null then v.enter_visit(n_then)
		var then_outset = v.current_outset

		v.current_inset = inset
		v.current_outset = outset

		if n_else != null then
			v.enter_visit(n_else)
			outset = v.merge(then_outset, v.current_outset)
		else
			outset = v.merge(then_outset, v.current_inset)
		end
		v.current_inset = inset
		v.current_outset = outset
	end
end

redef class AIfExpr
	redef fun accept_scope_visitor(v)
	do
		v.enter_visit(n_expr)
		v.enter_visit_block(n_then, null)
		v.enter_visit_block(n_else, null)
	end
end

redef class AIfExpr
	redef fun accept_flow_visitor(v)
	do
		var after_expr = v.visit_expr(self.n_expr)

		v.current_flow_context = after_expr.when_true
		v.enter_visit(self.n_then)
		var after_then = v.current_flow_context

		v.current_flow_context = after_expr.when_false
		v.enter_visit(self.n_else)
		var after_else = v.current_flow_context

		v.make_merge_flow(after_then, after_else)
	end
end

redef class AIfExpr
	redef fun accept_pretty_printer(v) do
		var before = v.indent
		var can_inline = v.can_inline(self)
		v.visit n_kwif
		v.adds

		if v.can_inline(n_expr) then
			v.visit n_expr
			v.adds
		else
			v.visit n_expr
			v.forcen
			v.addt
		end

		# skip comments before `then` token
		while not v.current_token isa TKwthen do v.skip
		v.consume "then"
		var n_else = self.n_else

		if can_inline then
			v.adds
			if n_then != null then v.visit n_then

			if has_else(v) then
				n_else.force_inline = true
				v.adds
				v.consume "else"
				v.adds
				v.visit n_else
			else if n_then == null then
				v.add "end"
			end
			v.skip_to last_token.last_real_token_in_line
		else
			v.finish_line
			if was_inline then
				v.forcen
			else if not v.skip_empty and n_then != null and
				n_then.was_inline and
				n_then.location.line_end == location.line_start then
				v.forcen # Xymus fucking syntax
			else
				v.addn
			end
			v.indent += 1

			if n_then != null then
				if n_then isa ABlockExpr then
					n_then.force_block = true
					v.visit n_then
				else
					v.addt
					v.visit n_then
					if n_then.was_inline then
						v.forcen
					else
						v.addn
					end
				end
			end

			v.consume_comments

			# FIXME: for some unknown reasons, has_else can be true even if
			# there is no `else` keyword but a `end` instead.
			if has_else(v) and v.current_token isa TKwelse then

				v.indent -= 1
				v.addt
				v.consume "else"

				if n_else isa AIfExpr then
					n_else.force_block = true
					v.adds
					v.visit n_else
				else
					v.finish_line
					if was_inline then
						v.forcen
					else
						v.addn
					end
					v.indent += 1

					if n_else isa ABlockExpr then
						n_else.force_block = true
						v.visit n_else
					else
						v.addt
						v.visit n_else
						if n_else.was_inline then
							v.forcen
						else
							v.addn
						end
					end

					if last_token isa TKwend then
						v.catch_up last_token
						v.indent -= 1
						v.addt
						v.consume "end"
					else
						v.indent -= 1
						v.addt
						v.add "end"
					end
				end
			else
				if last_token.location >= v.current_token.location then v.catch_up last_token
				v.indent -= 1
				v.addt
				v.add "end"
				if v.current_token isa TKwend then v.skip
			end
		end

		assert v.indent == before
	end

	redef fun is_inlinable do
		if not super then return false
		if n_then != null and not n_then.is_inlinable then return false
		var n_else = self.n_else
		if (n_else isa ABlockExpr and not n_else.n_expr.is_empty) or
		   (not n_else isa ABlockExpr and n_else != null) then
			return false
		end
		if not collect_comments.is_empty then return false
		return true
	end

	# Does this `if` statement contains a `else` part?
	private fun has_else(v: PrettyPrinterVisitor): Bool do
		var n_else = n_else
		if n_else == null then return false
		var n_kwelse = collect_kwelse
		if n_kwelse == null then return false

		if n_else isa ABlockExpr then
			var comments: Array[TComment]

			if n_then == null then
				comments = v.collect_comments(n_expr.last_token, n_else.last_token)
			else
				comments = v.collect_comments(n_then.last_token, n_else.last_token)
			end

			if not comments.is_empty then return true
			return not n_else.n_expr.is_empty
		end

		return true
	end

	# Lookup for `else` token in `self`.
	private fun collect_kwelse: nullable TKwelse do
		var token = first_token

		while token != last_token do
			if token isa TKwelse then return token
			token = token.next_token
		end

		return null
	end
end

redef class AIfExpr
	redef fun accept_typing(v)
	do
		v.visit_expr_bool(n_expr)

		v.visit_stmt(n_then)
		v.visit_stmt(n_else)

		self.is_typed = true

		if n_then != null and n_else == null then
			self.mtype = n_then.mtype
		end
	end
end

redef class AIfExpr
	private init make(condition: AExpr, mtype: nullable MType)
	do
		_n_kwif = new TKwif
		_n_expr = condition
		_n_expr.parent = self
		_n_kwthen = new TKwthen
		_n_then = new ABlockExpr.make
		_n_kwelse = new TKwelse
		_n_else = new ABlockExpr.make
		self.mtype = mtype
		if mtype != null then self.is_typed = true
	end
end

redef class AIfExpr
	redef fun expr(v)
	do
		var cond = v.expr(self.n_expr)
		if cond == null then return null
		if cond.is_true then
			return v.expr(self.n_then.as(not null))
		else
			return v.expr(self.n_else.as(not null))
		end
	end

	redef fun stmt(v)
	do
		var cond = v.expr(self.n_expr)
		if cond == null then return
		if cond.is_true then
			v.stmt(self.n_then)
		else
			v.stmt(self.n_else)
		end
	end
end