redef class AAssertExpr
	init init_aassertexpr (
		n_kwassert: nullable TKwassert,
		n_id: nullable TId,
		n_expr: nullable AExpr,
		n_kwelse: nullable TKwelse,
		n_else: nullable AExpr
	)
	do
		_n_kwassert = n_kwassert.as(not null)
		n_kwassert.parent = self
		_n_id = n_id
		if n_id != null then n_id.parent = self
		_n_expr = n_expr.as(not null)
		n_expr.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_kwassert == old_child then
			n_kwassert = new_child.as(TKwassert)
			return
		end
		if _n_id == old_child then
			n_id = new_child.as(nullable TId)
			return
		end
		if _n_expr == old_child then
			n_expr = new_child.as(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_kwassert=(node)
	do
		_n_kwassert = node
		node.parent = self
	end
	redef fun n_id=(node)
	do
		_n_id = node
		if node != null then node.parent = self
	end
	redef fun n_expr=(node)
	do
		_n_expr = node
		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_kwassert)
		v.enter_visit(_n_id)
		v.enter_visit(_n_expr)
		v.enter_visit(_n_kwelse)
		v.enter_visit(_n_else)
	end
end

redef class AAssertExpr
	# Superstring explaining `self` if the assert fails
	#
	# Engines should print out this superstring.
	fun explain_assert_str: nullable ASuperstringExpr do return null
end

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

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

		v.current_flow_context = after_expr.when_false
		v.enter_visit(n_else)
		# the after context of n_else is a dead end, so we do not care

		v.current_flow_context = after_expr.when_true
	end
end

redef class AAssertExpr
	redef fun accept_pretty_printer(v) do
		var can_inline = v.can_inline(self)
		v.visit n_kwassert

		if n_id != null then
			v.adds
			v.visit n_id
			v.consume ":"
		end

		v.adds
		v.visit n_expr
		var n_else = self.n_else

		if n_else != null then
			v.adds
			v.consume "else"

			if can_inline then
				v.adds
				v.visit n_else
			else
				v.addn
				v.indent += 1

				if n_else isa ABlockExpr then
					n_else.force_block = true
					v.visit n_else
					v.indent -= 1
					v.addt
					v.visit n_else.n_kwend
				else
					v.addt
					v.visit n_else
					v.forcen
					v.indent -= 1
					v.addt
					v.add "end"
				end
			end
		end
	end

	redef fun is_inlinable do
		if not super then return false
		if n_else != null and not n_else.is_inlinable then return false
		return true
	end
end

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

		v.visit_stmt(n_else)
		self.is_typed = true
	end
end

redef class AAssertExpr
	private init make(n_id : nullable TId , n_expr : nullable AExpr , n_else : nullable AExpr)
	do
		n_kwassert = new TKwassert
		n_kwelse = null
		if n_else != null then n_kwelse = new TKwelse
		self.init_aassertexpr(n_kwassert, n_id , n_expr , n_kwelse , n_else)
	end
end

redef class AAssertExpr
	redef fun accept_rapid_type_visitor(v)
	do
		if can_explain_assert(v.analysis.modelbuilder) then
			var str = explain_assert_str
			if str != null then str.accept_rapid_type_visitor(v)
		end
	end

	# Does `modelbuilder` know the classes to build a superstring to explain a failed assert?
	private fun can_explain_assert(modelbuilder: ModelBuilder): Bool
	do
		var nas = modelbuilder.model.get_mclasses_by_name("NativeArray")
		if nas == null then return false

		nas = modelbuilder.model.get_mclasses_by_name("Array")
		if nas == null or nas.is_empty then return false

		nas = modelbuilder.model.get_mclasses_by_name("String")
		if nas == null or nas.is_empty then return false

		return true
	end
end

redef class AAssertExpr
	redef fun stmt(v)
	do
		var cond = v.expr(self.n_expr)
		if cond == null then return
		if not cond.is_true then
			v.stmt(self.n_else)
			if v.is_escaping then return

			# Explain assert if it fails
			var explain_assert_str = explain_assert_str
			if explain_assert_str != null then
				var i = v.expr(explain_assert_str)
				if i isa MutableInstance then
					var res = v.send(v.force_get_primitive_method("to_cstring", i.mtype), [i])
					if res != null then
						var val = res.val
						if val != null then
							print_error "Runtime assert: {val.to_s}"
						end
					end
				end
			end

			var nid = self.n_id
			if nid != null then
				fatal(v, "Assert '{nid.text}' failed")
			else
				fatal(v, "Assert failed")
			end
			exit(1)
		end
	end
end

redef class AAssertExpr
	redef var explain_assert_str = null
end

redef class AAssertExpr
	redef fun generate_basic_blocks(ssa, old_block)
	do
		self.n_expr.generate_basic_blocks(ssa, old_block)

		# The condition of the assert is the last expression of the previous block
		old_block.last = self.n_expr

		# The block if the assert fail
		var block_false = new BasicBlock

		if self.n_else != null then
			block_false.first = self.n_else.as(not null)
			block_false.last = self.n_else.as(not null)
			self.n_else.generate_basic_blocks(ssa, block_false)
		else
			block_false.first = self
			block_false.last = self
		end

		old_block.link(block_false)

		# The block if the assert is true: the execution continue
		var block_true = new BasicBlock
		block_true.first = self
		block_true.last = self

		old_block.link(block_true)

		return block_true
	end
end

redef class AAssertExpr
	redef fun stmt(v)
	do
		if v.compiler.modelbuilder.toolcontext.opt_no_check_assert.value then return

		var cond = v.expr_bool(self.n_expr)
		v.add("if (unlikely(!{cond})) \{")
		v.stmt(self.n_else)

		explain_assert v

		var nid = self.n_id
		if nid != null then
			v.add_abort("Assert '{nid.text}' failed")
		else
			v.add_abort("Assert failed")
		end
		v.add("\}")
	end

	# Explain assert if it fails
	private fun explain_assert(v: AbstractCompilerVisitor)
	do
		var explain_assert_str = explain_assert_str
		if explain_assert_str == null then return

		var nas = v.compiler.modelbuilder.model.get_mclasses_by_name("NativeArray")
		if nas == null then return

		nas = v.compiler.modelbuilder.model.get_mclasses_by_name("Array")
		if nas == null or nas.is_empty then return

		var expr = explain_assert_str.expr(v)
		if expr == null then return

		var cstr = v.send(v.get_property("to_cstring", expr.mtype), [expr])
		if cstr == null then return

		v.add "PRINT_ERROR(\"Runtime assert: %s\\n\", {cstr});"
	end
end

redef class AAssertExpr
	redef fun decorate_tag(v, res, token)
	do
		if not token isa TId then return null
		res.add_class("nc_ast")
		return null
	end
end

redef class AAssertExpr
	redef fun stmt(v) do
		var cond = v.expr_bool(self.n_expr)
		v.add("if (!{cond}) \{")
		v.stmt(self.n_else)
		var nid = self.n_id
		if nid != null then
			v.add_abort("Assert '{nid.text}' failed")
		else
			v.add_abort("Assert failed")
		end
		v.add("\}")
	end
end