redef class AIsaExpr
	init init_aisaexpr (
		n_expr: nullable AExpr,
		n_kwisa: nullable TKwisa,
		n_type: nullable AType
	)
	do
		_n_expr = n_expr.as(not null)
		n_expr.parent = self
		_n_kwisa = n_kwisa.as(not null)
		n_kwisa.parent = self
		_n_type = n_type.as(not null)
		n_type.parent = self
	end

	redef fun replace_child(old_child: ANode, new_child: nullable ANode)
	do
		if _n_expr == old_child then
			n_expr = new_child.as(AExpr)
			return
		end
		if _n_kwisa == old_child then
			n_kwisa = new_child.as(TKwisa)
			return
		end
		if _n_type == old_child then
			n_type = new_child.as(AType)
			return
		end
	end

	redef fun n_expr=(node)
	do
		_n_expr = node
		node.parent = self
	end
	redef fun n_kwisa=(node)
	do
		_n_kwisa = node
		node.parent = self
	end
	redef fun n_type=(node)
	do
		_n_type = node
		node.parent = self
	end


	redef fun visit_all(v: Visitor)
	do
		v.enter_visit(_n_expr)
		v.enter_visit(_n_kwisa)
		v.enter_visit(_n_type)
	end
end

redef class AIsaExpr
	redef fun accept_flow_visitor(v)
	do
		super
		v.make_sub_true_false_flow
	end
end

redef class AIsaExpr
	redef fun accept_pretty_printer(v) do
		v.visit n_expr
		v.adds
		v.consume "isa"
		v.adds
		v.visit n_type
	end
end

redef class AIsaExpr
	# The static type to cast to.
	# (different from the static type of the expression that is `Bool`).
	var cast_type: nullable MType
	redef fun accept_typing(v)
	do
		v.visit_expr(n_expr)

		var mtype = v.resolve_mtype(n_type)

		self.cast_type = mtype

		var variable = self.n_expr.its_variable
		if variable != null then
			var orig = self.n_expr.mtype
			#var from = if orig != null then orig.to_s else "invalid"
			#var to = if mtype != null then mtype.to_s else "invalid"
			#debug("adapt {variable}: {from} -> {to}")

			var thentype = v.intersect_types(self, orig, mtype)
			if thentype != orig then
				self.after_flow_context.when_true.set_var(v, variable, thentype)
				#debug "{variable}:{orig or else "?"} isa {mtype or else "?"} -> then {thentype or else "?"}"
			end

			var elsetype = v.diff_types(self, orig, mtype)
			if elsetype != orig then
				self.after_flow_context.when_false.set_var(v, variable, elsetype)
				#debug "{variable}:{orig or else "?"} isa {mtype or else "?"} -> else {elsetype or else "?"}"
			end
		end

		self.mtype = v.type_bool(self)
	end

	redef fun accept_post_typing(v)
	do
		v.check_expr_cast(self, self.n_expr, self.n_type)
	end

	redef fun dump_info(v) do
		var res = super
		var mtype = self.cast_type
		if mtype != null then
			res += v.yellow(".as({mtype})")
		end
		return res
	end

end

redef class AIsaExpr
	redef fun accept_rapid_type_visitor(v)
	do
		var cast_type = self.cast_type
		if cast_type == null then return
		v.add_cast_type(cast_type)
	end
end

redef class AIsaExpr
	redef fun expr(v)
	do
		var i = v.expr(self.n_expr)
		if i == null then return null
		var mtype = v.unanchor_type(self.cast_type.as(not null))
		return v.bool_instance(v.is_subtype(i.mtype, mtype))
	end
end

redef class AIsaExpr
	redef fun accept_explain_assert(v)
	do
		if n_expr.mtype == null then return

		v.explain_expr n_expr
		v.explain_string " {n_kwisa.text} "
		v.explain_string n_type.collect_text
	end
end

redef class AIsaExpr
	# Identifier of the target class type
	var id: Int

	# If the Cohen test is used, the position of the target id in vtable
	var position: Int

	# Indicate the status of the optimization for this node
	#
	# 0 : the default value
	# 1 : this test can be implemented with direct access
	# 2 : this test must be implemented with perfect hashing
	var status: Int = 0

	redef fun expr(v)
	do
		# TODO : a workaround for now
		if not v isa VirtualMachine then return super

		var recv = v.expr(self.n_expr)
		if recv == null then return null

		optimize(v, recv.mtype, self.cast_type.as(not null))
		var mtype = v.unanchor_type(self.cast_type.as(not null))

		# If this test can be optimized, directly call appropriate subtyping methods
		if status == 1 and recv.mtype isa MClassType then
			# Direct access
			return v.bool_instance(v.inter_is_subtype_sst(id, position, recv.mtype.as(MClassType).mclass.vtable.internal_vtable))
		else if status == 2 and recv.mtype isa MClassType then
			# Perfect hashing
			return v.bool_instance(v.inter_is_subtype_ph(id, recv.vtable.mask, recv.mtype.as(MClassType).mclass.vtable.internal_vtable))
		else
			# Use the slow path (default)
			return v.bool_instance(v.is_subtype(recv.mtype, mtype))
		end
	end

	# Optimize a `AIsaExpr`
	# `source` the source type of the expression
	# `target` the target type of the subtyping test
	private fun optimize(v: VirtualMachine, source: MType, target: MType)
	do
		# If the source class and target class are not classic classes (non-generics) then return
		if not source isa MClassType or not target isa MClassType or target isa MGenericType then
			return
		end

		if not target.mclass.abstract_loaded then return

		# If the value is positive, the target class has an invariant position in source's structures
		var value = source.mclass.get_position_methods(target.mclass)

		if value > 0 then
			# `value - 2` is the position of the target identifier in source vtable
			position = value - 2
			status = 1
		else
			# We use perfect hashing
			status = 2
		end
		id = target.mclass.vtable.id
	end
end

redef class AIsaExpr
	redef fun generate_basic_blocks(ssa, old_block)
	do
		ssa.propdef.object_sites.add(self)

		return self.n_expr.generate_basic_blocks(ssa, old_block)
	end
end

redef class AIsaExpr
	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, "isa")
	end
end

redef class AIsaExpr
	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
end