# A visitor on the AST of property definition that generate the C code of a separate compilation process.
class SeparateCompilerVisitor
	super AbstractCompilerVisitor

	redef type COMPILER: SeparateCompiler

	redef fun adapt_signature(m, args)
	do
		var msignature = m.msignature.resolve_for(m.mclassdef.bound_mtype, m.mclassdef.bound_mtype, m.mclassdef.mmodule, true)
		var recv = args.first
		if recv.mtype.ctype != m.mclassdef.mclass.mclass_type.ctype then
			args.first = self.autobox(args.first, m.mclassdef.mclass.mclass_type)
		end
		for i in [0..msignature.arity[ do
			var mp = msignature.mparameters[i]
			var t = mp.mtype
			if mp.is_vararg then
				t = args[i+1].mtype
			end
			args[i+1] = self.autobox(args[i+1], t)
		end
	end

	redef fun unbox_signature_extern(m, args)
	do
		var msignature = m.msignature.resolve_for(m.mclassdef.bound_mtype, m.mclassdef.bound_mtype, m.mclassdef.mmodule, true)
		if not m.mproperty.is_init and m.is_extern then
			args.first = self.unbox_extern(args.first, m.mclassdef.mclass.mclass_type)
		end
		for i in [0..msignature.arity[ do
			var mp = msignature.mparameters[i]
			var t = mp.mtype
			if mp.is_vararg then
				t = args[i+1].mtype
			end
			if m.is_extern then args[i+1] = self.unbox_extern(args[i+1], t)
		end
	end

	redef fun autobox(value, mtype)
	do
		if value.mtype == mtype then
			return value
		else if not value.mtype.is_c_primitive and not mtype.is_c_primitive then
			return value
		else if not value.mtype.is_c_primitive then
			if mtype.is_tagged then
				if mtype.name == "Int" then
					return self.new_expr("(long)({value})>>2", mtype)
				else if mtype.name == "Char" then
					return self.new_expr("(uint32_t)((long)({value})>>2)", mtype)
				else if mtype.name == "Bool" then
					return self.new_expr("(short int)((long)({value})>>2)", mtype)
				else
					abort
				end
			end
			return self.new_expr("((struct instance_{mtype.c_name}*){value})->value; /* autounbox from {value.mtype} to {mtype} */", mtype)
		else if not mtype.is_c_primitive then
			assert value.mtype == value.mcasttype
			if value.mtype.is_tagged then
				var res
				if value.mtype.name == "Int" then
					res = self.new_expr("(val*)({value}<<2|1)", mtype)
				else if value.mtype.name == "Char" then
					res = self.new_expr("(val*)((long)({value})<<2|2)", mtype)
				else if value.mtype.name == "Bool" then
					res = self.new_expr("(val*)((long)({value})<<2|3)", mtype)
				else
					abort
				end
				# Do not loose type info
				res.mcasttype = value.mcasttype
				return res
			end
			var valtype = value.mtype.as(MClassType)
			if mtype isa MClassType and mtype.mclass.kind == extern_kind and mtype.mclass.name != "CString" then
				valtype = compiler.mainmodule.pointer_type
			end
			var res = self.new_var(mtype)
			# Do not loose type info
			res.mcasttype = value.mcasttype
			self.require_declaration("BOX_{valtype.c_name}")
			self.add("{res} = BOX_{valtype.c_name}({value}); /* autobox from {value.mtype} to {mtype} */")
			return res
		else if (value.mtype.ctype == "void*" and mtype.ctype == "void*") or
			(value.mtype.ctype == "char*" and mtype.ctype == "void*") or
			(value.mtype.ctype == "void*" and mtype.ctype == "char*") then
			return value
		else
			# Bad things will appen!
			var res = self.new_var(mtype)
			self.add("/* {res} left unintialized (cannot convert {value.mtype} to {mtype}) */")
			self.add("PRINT_ERROR(\"Cast error: Cannot cast %s to %s.\\n\", \"{value.mtype}\", \"{mtype}\"); fatal_exit(1);")
			return res
		end
	end

	redef fun unbox_extern(value, mtype)
	do
		if mtype isa MClassType and mtype.mclass.kind == extern_kind and
		   mtype.mclass.name != "CString" then
			var pointer_type = compiler.mainmodule.pointer_type
			var res = self.new_var_extern(mtype)
			self.add "{res} = ((struct instance_{pointer_type.c_name}*){value})->value; /* unboxing {value.mtype} */"
			return res
		else
			return value
		end
	end

	redef fun box_extern(value, mtype)
	do
		if mtype isa MClassType and mtype.mclass.kind == extern_kind and
		   mtype.mclass.name != "CString" then
			var valtype = compiler.mainmodule.pointer_type
			var res = self.new_var(mtype)
			compiler.undead_types.add(mtype)
			self.require_declaration("BOX_{valtype.c_name}")
			self.add("{res} = BOX_{valtype.c_name}({value}); /* boxing {value.mtype} */")
			self.require_declaration("type_{mtype.c_name}")
			self.add("{res}->type = &type_{mtype.c_name};")
			self.require_declaration("class_{mtype.c_name}")
			self.add("{res}->class = &class_{mtype.c_name};")
			return res
		else
			return value
		end
	end

	# Returns a C expression containing the tag of the value as a long.
	#
	# If the C expression is evaluated to 0, it means there is no tag.
	# Thus the expression can be used as a condition.
	fun extract_tag(value: RuntimeVariable): String
	do
		assert not value.mtype.is_c_primitive
		return "((long){value}&3)" # Get the two low bits
	end

	# Returns a C expression of the runtime class structure of the value.
	# The point of the method is to work also with primitive types.
	fun class_info(value: RuntimeVariable): String
	do
		if not value.mtype.is_c_primitive then
			if can_be_primitive(value) and not compiler.modelbuilder.toolcontext.opt_no_tag_primitives.value then
				var tag = extract_tag(value)
				return "({tag}?class_info[{tag}]:{value}->class)"
			end
			return "{value}->class"
		else
			compiler.undead_types.add(value.mtype)
			self.require_declaration("class_{value.mtype.c_name}")
			return "(&class_{value.mtype.c_name})"
		end
	end

	# Returns a C expression of the runtime type structure of the value.
	# The point of the method is to work also with primitive types.
	fun type_info(value: RuntimeVariable): String
	do
		if not value.mtype.is_c_primitive then
			if can_be_primitive(value) and not compiler.modelbuilder.toolcontext.opt_no_tag_primitives.value then
				var tag = extract_tag(value)
				return "({tag}?type_info[{tag}]:{value}->type)"
			end
			return "{value}->type"
		else
			compiler.undead_types.add(value.mtype)
			self.require_declaration("type_{value.mtype.c_name}")
			return "(&type_{value.mtype.c_name})"
		end
	end

	redef fun compile_callsite(callsite, args)
	do
		var rta = compiler.runtime_type_analysis
		# TODO: Inlining of new-style constructors with initializers
		if compiler.modelbuilder.toolcontext.opt_direct_call_monomorph.value and rta != null and callsite.mpropdef.initializers.is_empty then
			var tgs = rta.live_targets(callsite)
			if tgs.length == 1 then
				return direct_call(tgs.first, args)
			end
		end
		# Shortcut intern methods as they are not usually redefinable
		if callsite.mpropdef.is_intern and callsite.mproperty.name != "object_id" then
			# `object_id` is the only redefined intern method, so it can not be directly called.
			# TODO find a less ugly approach?
			return direct_call(callsite.mpropdef, args)
		end
		return super
	end

	# Fully and directly call a mpropdef
	#
	# This method is used by `compile_callsite`
	private fun direct_call(mpropdef: MMethodDef, args: Array[RuntimeVariable]): nullable RuntimeVariable
	do
		var res0 = before_send(mpropdef.mproperty, args)
		var res = call(mpropdef, mpropdef.mclassdef.bound_mtype, args)
		if res0 != null then
			assert res != null
			self.assign(res0, res)
			res = res0
		end
		add("\}") # close the before_send
		return res
	end
	redef fun send(mmethod, arguments)
	do
		if arguments.first.mcasttype.is_c_primitive then
			# In order to shortcut the primitive, we need to find the most specific method
			# Howverr, because of performance (no flattening), we always work on the realmainmodule
			var m = self.compiler.mainmodule
			self.compiler.mainmodule = self.compiler.realmainmodule
			var res = self.monomorphic_send(mmethod, arguments.first.mcasttype, arguments)
			self.compiler.mainmodule = m
			return res
		end

		return table_send(mmethod, arguments, mmethod)
	end

	# Handle common special cases before doing the effective method invocation
	# This methods handle the `==` and `!=` methods and the case of the null receiver.
	# Note: a { is open in the generated C, that enclose and protect the effective method invocation.
	# Client must not forget to close the } after them.
	#
	# The value returned is the result of the common special cases.
	# If not null, client must compile it with the result of their own effective method invocation.
	#
	# If `before_send` can shortcut the whole message sending, a dummy `if(0){`
	# is generated to cancel the effective method invocation that will follow
	# TODO: find a better approach
	private fun before_send(mmethod: MMethod, arguments: Array[RuntimeVariable]): nullable RuntimeVariable
	do
		var res: nullable RuntimeVariable = null
		var recv = arguments.first
		var consider_null = not self.compiler.modelbuilder.toolcontext.opt_no_check_null.value or mmethod.name == "==" or mmethod.name == "!="
		if maybe_null(recv) and consider_null then
			self.add("if ({recv} == NULL) \{")
			if mmethod.name == "==" or mmethod.name == "is_same_instance" then
				res = self.new_var(bool_type)
				var arg = arguments[1]
				if arg.mcasttype isa MNullableType then
					self.add("{res} = ({arg} == NULL);")
				else if arg.mcasttype isa MNullType then
					self.add("{res} = 1; /* is null */")
				else
					self.add("{res} = 0; /* {arg.inspect} cannot be null */")
				end
			else if mmethod.name == "!=" then
				res = self.new_var(bool_type)
				var arg = arguments[1]
				if arg.mcasttype isa MNullableType then
					self.add("{res} = ({arg} != NULL);")
				else if arg.mcasttype isa MNullType then
					self.add("{res} = 0; /* is null */")
				else
					self.add("{res} = 1; /* {arg.inspect} cannot be null */")
				end
			else
				self.add_abort("Receiver is null")
			end
			self.add("\} else \{")
		else
			self.add("\{")
		end
		if not self.compiler.modelbuilder.toolcontext.opt_no_shortcut_equate.value and (mmethod.name == "==" or mmethod.name == "!=" or mmethod.name == "is_same_instance") then
			# Recv is not null, thus if arg is, it is easy to conclude (and respect the invariants)
			var arg = arguments[1]
			if arg.mcasttype isa MNullType then
				if res == null then res = self.new_var(bool_type)
				if mmethod.name == "!=" then
					self.add("{res} = 1; /* arg is null and recv is not */")
				else # `==` and `is_same_instance`
					self.add("{res} = 0; /* arg is null but recv is not */")
				end
				self.add("\}") # closes the null case
				self.add("if (0) \{") # what follow is useless, CC will drop it
			end
		end
		return res
	end

	private fun table_send(mmethod: MMethod, arguments: Array[RuntimeVariable], mentity: MEntity): nullable RuntimeVariable
	do
		compiler.modelbuilder.nb_invok_by_tables += 1
		if compiler.modelbuilder.toolcontext.opt_invocation_metrics.value then add("count_invoke_by_tables++;")

		assert arguments.length == mmethod.intro.msignature.arity + 1 else debug("Invalid arity for {mmethod}. {arguments.length} arguments given.")

		var res0 = before_send(mmethod, arguments)

		var runtime_function = mmethod.intro.virtual_runtime_function
		var msignature = runtime_function.called_signature

		adapt_signature(mmethod.intro, arguments)

		var res: nullable RuntimeVariable
		var ret = msignature.return_mtype
		if ret == null then
			res = null
		else
			res = self.new_var(ret)
		end

		var ss = arguments.join(", ")

		var const_color = mentity.const_color
		var ress
		if res != null then
			ress = "{res} = "
		else
			ress = ""
		end
		if mentity isa MMethod and compiler.modelbuilder.toolcontext.opt_direct_call_monomorph0.value then
			# opt_direct_call_monomorph0 is used to compare the efficiency of the alternative lookup implementation, ceteris paribus.
			# The difference with the non-zero option is that the monomorphism is looked-at on the mmethod level and not at the callsite level.
			# TODO: remove this mess and use per callsite service to detect monomorphism in a single place.
			var md = compiler.is_monomorphic(mentity)
			if md != null then
				var callsym = md.virtual_runtime_function.c_name
				self.require_declaration(callsym)
				self.add "{ress}{callsym}({ss}); /* {mmethod} on {arguments.first.inspect}*/"
			else
				self.require_declaration(const_color)
				self.add "{ress}(({runtime_function.c_funptrtype})({class_info(arguments.first)}->vft[{const_color}]))({ss}); /* {mmethod} on {arguments.first.inspect}*/"
			end
		else if mentity isa MMethod and compiler.modelbuilder.toolcontext.opt_guard_call.value then
			var callsym = "CALL_" + const_color
			self.require_declaration(callsym)
			self.add "if (!{callsym}) \{"
			self.require_declaration(const_color)
			self.add "{ress}(({runtime_function.c_funptrtype})({class_info(arguments.first)}->vft[{const_color}]))({ss}); /* {mmethod} on {arguments.first.inspect}*/"
			self.add "\} else \{"
			self.add "{ress}{callsym}({ss}); /* {mmethod} on {arguments.first.inspect}*/"
			self.add "\}"
		else if mentity isa MMethod and compiler.modelbuilder.toolcontext.opt_trampoline_call.value then
			var callsym = "CALL_" + const_color
			self.require_declaration(callsym)
			self.add "{ress}{callsym}({ss}); /* {mmethod} on {arguments.first.inspect}*/"
		else
			self.require_declaration(const_color)
			self.add "{ress}(({runtime_function.c_funptrtype})({class_info(arguments.first)}->vft[{const_color}]))({ss}); /* {mmethod} on {arguments.first.inspect}*/"
		end

		if res0 != null then
			assert res != null
			assign(res0,res)
			res = res0
		end

		self.add("\}") # closes the null case

		return res
	end

	redef fun call(mmethoddef, recvtype, arguments)
	do
		assert arguments.length == mmethoddef.msignature.arity + 1 else debug("Invalid arity for {mmethoddef}. {arguments.length} arguments given.")

		var res: nullable RuntimeVariable
		var ret = mmethoddef.msignature.return_mtype
		if ret == null then
			res = null
		else
			ret = ret.resolve_for(mmethoddef.mclassdef.bound_mtype, mmethoddef.mclassdef.bound_mtype, mmethoddef.mclassdef.mmodule, true)
			res = self.new_var(ret)
		end

		if (mmethoddef.is_intern and not compiler.modelbuilder.toolcontext.opt_no_inline_intern.value) or
			(compiler.modelbuilder.toolcontext.opt_inline_some_methods.value and mmethoddef.can_inline(self)) then
			compiler.modelbuilder.nb_invok_by_inline += 1
			if compiler.modelbuilder.toolcontext.opt_invocation_metrics.value then add("count_invoke_by_inline++;")
			var frame = new StaticFrame(self, mmethoddef, recvtype, arguments)
			frame.returnlabel = self.get_name("RET_LABEL")
			frame.returnvar = res
			var old_frame = self.frame
			self.frame = frame
			self.add("\{ /* Inline {mmethoddef} ({arguments.join(",")}) on {arguments.first.inspect} */")
			mmethoddef.compile_inside_to_c(self, arguments)
			self.add("{frame.returnlabel.as(not null)}:(void)0;")
			self.add("\}")
			self.frame = old_frame
			return res
		end
		compiler.modelbuilder.nb_invok_by_direct += 1
		if compiler.modelbuilder.toolcontext.opt_invocation_metrics.value then add("count_invoke_by_direct++;")

		# Autobox arguments
		self.adapt_signature(mmethoddef, arguments)

		self.require_declaration(mmethoddef.c_name)
		if res == null then
			self.add("{mmethoddef.c_name}({arguments.join(", ")}); /* Direct call {mmethoddef} on {arguments.first.inspect}*/")
			return null
		else
			self.add("{res} = {mmethoddef.c_name}({arguments.join(", ")});")
		end

		return res
	end

	redef fun supercall(m: MMethodDef, recvtype: MClassType, arguments: Array[RuntimeVariable]): nullable RuntimeVariable
	do
		if arguments.first.mcasttype.is_c_primitive then
			# In order to shortcut the primitive, we need to find the most specific method
			# However, because of performance (no flattening), we always work on the realmainmodule
			var main = self.compiler.mainmodule
			self.compiler.mainmodule = self.compiler.realmainmodule
			var res = self.monomorphic_super_send(m, recvtype, arguments)
			self.compiler.mainmodule = main
			return res
		end
		return table_send(m.mproperty, arguments, m)
	end

	redef fun vararg_instance(mpropdef, recv, varargs, elttype)
	do
		# A vararg must be stored into an new array
		# The trick is that the dymaic type of the array may depends on the receiver
		# of the method (ie recv) if the static type is unresolved
		# This is more complex than usual because the unresolved type must not be resolved
		# with the current receiver (ie self).
		# Therefore to isolate the resolution from self, a local StaticFrame is created.
		# One can see this implementation as an inlined method of the receiver whose only
		# job is to allocate the array
		var old_frame = self.frame
		var frame = new StaticFrame(self, mpropdef, mpropdef.mclassdef.bound_mtype, [recv])
		self.frame = frame
		#print "required Array[{elttype}] for recv {recv.inspect}. bound=Array[{self.resolve_for(elttype, recv)}]. selfvar={frame.arguments.first.inspect}"
		var res = self.array_instance(varargs, elttype)
		self.frame = old_frame
		return res
	end

	redef fun isset_attribute(a, recv)
	do
		self.check_recv_notnull(recv)
		var res = self.new_var(bool_type)

		# What is the declared type of the attribute?
		var mtype = a.intro.static_mtype.as(not null)
		var intromclassdef = a.intro.mclassdef
		mtype = mtype.resolve_for(intromclassdef.bound_mtype, intromclassdef.bound_mtype, intromclassdef.mmodule, true)

		if mtype isa MNullableType then
			self.add("{res} = 1; /* easy isset: {a} on {recv.inspect} */")
			return res
		end

		self.require_declaration(a.const_color)
		if self.compiler.modelbuilder.toolcontext.opt_no_union_attribute.value then
			self.add("{res} = {recv}->attrs[{a.const_color}] != NULL; /* {a} on {recv.inspect}*/")
		else

			if not mtype.is_c_primitive and not mtype.is_tagged then
				self.add("{res} = {recv}->attrs[{a.const_color}].val != NULL; /* {a} on {recv.inspect} */")
			else
				self.add("{res} = 1; /* NOT YET IMPLEMENTED: isset of primitives: {a} on {recv.inspect} */")
			end
		end
		return res
	end

	redef fun read_attribute(a, recv)
	do
		self.check_recv_notnull(recv)

		# What is the declared type of the attribute?
		var ret = a.intro.static_mtype.as(not null)
		var intromclassdef = a.intro.mclassdef
		ret = ret.resolve_for(intromclassdef.bound_mtype, intromclassdef.bound_mtype, intromclassdef.mmodule, true)

		if self.compiler.modelbuilder.toolcontext.opt_isset_checks_metrics.value then
			self.compiler.attr_read_count += 1
			self.add("count_attr_reads++;")
		end

		self.require_declaration(a.const_color)
		if self.compiler.modelbuilder.toolcontext.opt_no_union_attribute.value then
			# Get the attribute or a box (ie. always a val*)
			var cret = self.object_type.as_nullable
			var res = self.new_var(cret)
			res.mcasttype = ret

			self.add("{res} = {recv}->attrs[{a.const_color}]; /* {a} on {recv.inspect} */")

			# Check for Uninitialized attribute
			if not ret isa MNullableType and not self.compiler.modelbuilder.toolcontext.opt_no_check_attr_isset.value then
				self.add("if (unlikely({res} == NULL)) \{")
				self.add_abort("Uninitialized attribute {a.name}")
				self.add("\}")

				if self.compiler.modelbuilder.toolcontext.opt_isset_checks_metrics.value then
					self.compiler.isset_checks_count += 1
					self.add("count_isset_checks++;")
				end
			end

			# Return the attribute or its unboxed version
			# Note: it is mandatory since we reuse the box on write, we do not whant that the box escapes
			return self.autobox(res, ret)
		else
			var res = self.new_var(ret)
			self.add("{res} = {recv}->attrs[{a.const_color}].{ret.ctypename}; /* {a} on {recv.inspect} */")

			# Check for Uninitialized attribute
			if not ret.is_c_primitive and not ret isa MNullableType and not self.compiler.modelbuilder.toolcontext.opt_no_check_attr_isset.value then
				self.add("if (unlikely({res} == NULL)) \{")
				self.add_abort("Uninitialized attribute {a.name}")
				self.add("\}")
				if self.compiler.modelbuilder.toolcontext.opt_isset_checks_metrics.value then
					self.compiler.isset_checks_count += 1
					self.add("count_isset_checks++;")
				end
			end

			return res
		end
	end

	redef fun write_attribute(a, recv, value)
	do
		self.check_recv_notnull(recv)

		# What is the declared type of the attribute?
		var mtype = a.intro.static_mtype.as(not null)
		var intromclassdef = a.intro.mclassdef
		mtype = mtype.resolve_for(intromclassdef.bound_mtype, intromclassdef.bound_mtype, intromclassdef.mmodule, true)

		# Adapt the value to the declared type
		value = self.autobox(value, mtype)

		self.require_declaration(a.const_color)
		if self.compiler.modelbuilder.toolcontext.opt_no_union_attribute.value then
			var attr = "{recv}->attrs[{a.const_color}]"
			if mtype.is_tagged then
				# The attribute is not primitive, thus store it as tagged
				var tv = autobox(value, compiler.mainmodule.object_type)
				self.add("{attr} = {tv}; /* {a} on {recv.inspect} */")
			else if mtype.is_c_primitive then
				assert mtype isa MClassType
				# The attribute is primitive, thus we store it in a box
				# The trick is to create the box the first time then resuse the box
				self.add("if ({attr} != NULL) \{")
				self.add("((struct instance_{mtype.c_name}*){attr})->value = {value}; /* {a} on {recv.inspect} */")
				self.add("\} else \{")
				value = self.autobox(value, self.object_type.as_nullable)
				self.add("{attr} = {value}; /* {a} on {recv.inspect} */")
				self.add("\}")
			else
				# The attribute is not primitive, thus store it direclty
				self.add("{attr} = {value}; /* {a} on {recv.inspect} */")
			end
		else
			self.add("{recv}->attrs[{a.const_color}].{mtype.ctypename} = {value}; /* {a} on {recv.inspect} */")
		end
	end

	# Check that mtype is a live open type
	fun hardening_live_open_type(mtype: MType)
	do
		if not compiler.modelbuilder.toolcontext.opt_hardening.value then return
		self.require_declaration(mtype.const_color)
		var col = mtype.const_color
		self.add("if({col} == -1) \{")
		self.add("PRINT_ERROR(\"Resolution of a dead open type: %s\\n\", \"{mtype.to_s.escape_to_c}\");")
		self.add_abort("open type dead")
		self.add("\}")
	end

	# Check that mtype it a pointer to a live cast type
	fun hardening_cast_type(t: String)
	do
		if not compiler.modelbuilder.toolcontext.opt_hardening.value then return
		add("if({t} == NULL) \{")
		add_abort("cast type null")
		add("\}")
		add("if({t}->id == -1 || {t}->color == -1) \{")
		add("PRINT_ERROR(\"Try to cast on a dead cast type: %s\\n\", {t}->name);")
		add_abort("cast type dead")
		add("\}")
	end

	redef fun init_instance(mtype)
	do
		self.require_declaration("NEW_{mtype.mclass.c_name}")
		var compiler = self.compiler
		if mtype isa MGenericType and mtype.need_anchor then
			hardening_live_open_type(mtype)
			link_unresolved_type(self.frame.mpropdef.mclassdef, mtype)
			var recv = self.frame.arguments.first
			var recv_type_info = self.type_info(recv)
			self.require_declaration(mtype.const_color)
			return self.new_expr("NEW_{mtype.mclass.c_name}({recv_type_info}->resolution_table->types[{mtype.const_color}])", mtype)
		end
		compiler.undead_types.add(mtype)
		self.require_declaration("type_{mtype.c_name}")
		return self.new_expr("NEW_{mtype.mclass.c_name}(&type_{mtype.c_name})", mtype)
	end

	redef fun type_test(value, mtype, tag)
	do
		self.add("/* {value.inspect} isa {mtype} */")
		var compiler = self.compiler

		var recv = self.frame.arguments.first
		var recv_type_info = self.type_info(recv)

		var res = self.new_var(bool_type)

		var cltype = self.get_name("cltype")
		self.add_decl("int {cltype};")
		var idtype = self.get_name("idtype")
		self.add_decl("int {idtype};")

		var maybe_null = self.maybe_null(value)
		var accept_null = "0"
		var ntype = mtype
		if ntype isa MNullableType then
			ntype = ntype.mtype
			accept_null = "1"
		end

		if value.mcasttype.is_subtype(self.frame.mpropdef.mclassdef.mmodule, self.frame.mpropdef.mclassdef.bound_mtype, mtype) then
			self.add("{res} = 1; /* easy {value.inspect} isa {mtype}*/")
			if compiler.modelbuilder.toolcontext.opt_typing_test_metrics.value then
				self.compiler.count_type_test_skipped[tag] += 1
				self.add("count_type_test_skipped_{tag}++;")
			end
			return res
		end

		if ntype.need_anchor then
			var type_struct = self.get_name("type_struct")
			self.add_decl("const struct type* {type_struct};")

			# Either with resolution_table with a direct resolution
			hardening_live_open_type(mtype)
			link_unresolved_type(self.frame.mpropdef.mclassdef, mtype)
			self.require_declaration(mtype.const_color)
			self.add("{type_struct} = {recv_type_info}->resolution_table->types[{mtype.const_color}];")
			if compiler.modelbuilder.toolcontext.opt_typing_test_metrics.value then
				self.compiler.count_type_test_unresolved[tag] += 1
				self.add("count_type_test_unresolved_{tag}++;")
			end
			hardening_cast_type(type_struct)
			self.add("{cltype} = {type_struct}->color;")
			self.add("{idtype} = {type_struct}->id;")
			if maybe_null and accept_null == "0" then
				var is_nullable = self.get_name("is_nullable")
				self.add_decl("short int {is_nullable};")
				self.add("{is_nullable} = {type_struct}->is_nullable;")
				accept_null = is_nullable.to_s
			end
		else if ntype isa MClassType then
			compiler.undead_types.add(mtype)
			self.require_declaration("type_{mtype.c_name}")
			hardening_cast_type("(&type_{mtype.c_name})")
			self.add("{cltype} = type_{mtype.c_name}.color;")
			self.add("{idtype} = type_{mtype.c_name}.id;")
			if compiler.modelbuilder.toolcontext.opt_typing_test_metrics.value then
				self.compiler.count_type_test_resolved[tag] += 1
				self.add("count_type_test_resolved_{tag}++;")
			end
		else
			self.add("PRINT_ERROR(\"NOT YET IMPLEMENTED: type_test(%s, {mtype}).\\n\", \"{value.inspect}\"); fatal_exit(1);")
		end

		# check color is in table
		if maybe_null then
			self.add("if({value} == NULL) \{")
			self.add("{res} = {accept_null};")
			self.add("\} else \{")
		end
		var value_type_info = self.type_info(value)
		self.add("if({cltype} >= {value_type_info}->table_size) \{")
		self.add("{res} = 0;")
		self.add("\} else \{")
		self.add("{res} = {value_type_info}->type_table[{cltype}] == {idtype};")
		self.add("\}")
		if maybe_null then
			self.add("\}")
		end

		return res
	end

	redef fun is_same_type_test(value1, value2)
	do
		var res = self.new_var(bool_type)
		# Swap values to be symetric
		if value2.mtype.is_c_primitive and not value1.mtype.is_c_primitive then
			var tmp = value1
			value1 = value2
			value2 = tmp
		end
		if value1.mtype.is_c_primitive then
			if value2.mtype == value1.mtype then
				self.add("{res} = 1; /* is_same_type_test: compatible types {value1.mtype} vs. {value2.mtype} */")
			else if value2.mtype.is_c_primitive then
				self.add("{res} = 0; /* is_same_type_test: incompatible types {value1.mtype} vs. {value2.mtype}*/")
			else
				var mtype1 = value1.mtype.as(MClassType)
				self.require_declaration("class_{mtype1.c_name}")
				self.add("{res} = ({value2} != NULL) && ({class_info(value2)} == &class_{mtype1.c_name}); /* is_same_type_test */")
			end
		else
			self.add("{res} = ({value1} == {value2}) || ({value1} != NULL && {value2} != NULL && {class_info(value1)} == {class_info(value2)}); /* is_same_type_test */")
		end
		return res
	end

	redef fun class_name_string(value)
	do
		var res = self.get_name("var_class_name")
		self.add_decl("const char* {res};")
		if not value.mtype.is_c_primitive then
			self.add "{res} = {value} == NULL ? \"null\" : {type_info(value)}->name;"
		else if value.mtype isa MClassType and value.mtype.as(MClassType).mclass.kind == extern_kind and
			value.mtype.as(MClassType).name != "CString" then
			self.add "{res} = \"{value.mtype.as(MClassType).mclass}\";"
		else
			self.require_declaration("type_{value.mtype.c_name}")
			self.add "{res} = type_{value.mtype.c_name}.name;"
		end
		return res
	end

	redef fun equal_test(value1, value2)
	do
		var res = self.new_var(bool_type)
		if value2.mtype.is_c_primitive and not value1.mtype.is_c_primitive then
			var tmp = value1
			value1 = value2
			value2 = tmp
		end
		if value1.mtype.is_c_primitive then
			var t1 = value1.mtype
			assert t1 == value1.mcasttype

			# Fast case: same C type.
			if value2.mtype == t1 then
				# Same exact C primitive representation.
				self.add("{res} = {value1} == {value2};")
				return res
			end

			# Complex case: value2 has a different representation
			# Thus, it should be checked if `value2` is type-compatible with `value1`
			# This compatibility is done statically if possible and dynamically else

			# Conjunction (ands) of dynamic tests according to the static knowledge
			var tests = new Array[String]

			var t2 = value2.mcasttype
			if t2 isa MNullableType then
				# The destination type cannot be null
				tests.add("({value2} != NULL)")
				t2 = t2.mtype
			else if t2 isa MNullType then
				# `value2` is known to be null, thus incompatible with a primitive
				self.add("{res} = 0; /* incompatible types {t1} vs. {t2}*/")
				return res
			end

			if t2 == t1 then
				# Same type but different representation.
			else if t2.is_c_primitive then
				# Type of `value2` is a different primitive type, thus incompatible
				self.add("{res} = 0; /* incompatible types {t1} vs. {t2}*/")
				return res
			else if t1.is_tagged then
				# To be equal, `value2` should also be correctly tagged
				tests.add("({extract_tag(value2)} == {t1.tag_value})")
			else
				# To be equal, `value2` should also be boxed with the same class
				self.require_declaration("class_{t1.c_name}")
				tests.add "({class_info(value2)} == &class_{t1.c_name})"
			end

			# Compare the unboxed `value2` with `value1`
			if tests.not_empty then
				self.add "if ({tests.join(" && ")}) \{"
			end
			self.add "{res} = {self.autobox(value2, t1)} == {value1};"
			if tests.not_empty then
				self.add "\} else {res} = 0;"
			end

			return res
		end
		var maybe_null = true
		var test = new Array[String]
		var t1 = value1.mcasttype
		if t1 isa MNullableType then
			test.add("{value1} != NULL")
			t1 = t1.mtype
		else
			maybe_null = false
		end
		var t2 = value2.mcasttype
		if t2 isa MNullableType then
			test.add("{value2} != NULL")
			t2 = t2.mtype
		else
			maybe_null = false
		end

		var incompatible = false
		var primitive
		if t1.is_c_primitive then
			primitive = t1
			if t1 == t2 then
				# No need to compare class
			else if t2.is_c_primitive then
				incompatible = true
			else if can_be_primitive(value2) then
				if t1.is_tagged then
					self.add("{res} = {value1} == {value2};")
					return res
				end
				if not compiler.modelbuilder.toolcontext.opt_no_tag_primitives.value then
					test.add("(!{extract_tag(value2)})")
				end
				test.add("{value1}->class == {value2}->class")
			else
				incompatible = true
			end
		else if t2.is_c_primitive then
			primitive = t2
			if can_be_primitive(value1) then
				if t2.is_tagged then
					self.add("{res} = {value1} == {value2};")
					return res
				end
				if not compiler.modelbuilder.toolcontext.opt_no_tag_primitives.value then
					test.add("(!{extract_tag(value1)})")
				end
				test.add("{value1}->class == {value2}->class")
			else
				incompatible = true
			end
		else
			primitive = null
		end

		if incompatible then
			if maybe_null then
				self.add("{res} = {value1} == {value2}; /* incompatible types {t1} vs. {t2}; but may be NULL*/")
				return res
			else
				self.add("{res} = 0; /* incompatible types {t1} vs. {t2}; cannot be NULL */")
				return res
			end
		end
		if primitive != null then
			if primitive.is_tagged then
				self.add("{res} = {value1} == {value2};")
				return res
			end
			test.add("((struct instance_{primitive.c_name}*){value1})->value == ((struct instance_{primitive.c_name}*){value2})->value")
		else if can_be_primitive(value1) and can_be_primitive(value2) then
			if not compiler.modelbuilder.toolcontext.opt_no_tag_primitives.value then
				test.add("(!{extract_tag(value1)}) && (!{extract_tag(value2)})")
			end
			test.add("{value1}->class == {value2}->class")
			var s = new Array[String]
			for t, v in self.compiler.box_kinds do
				if t.mclass_type.is_tagged then continue
				s.add "({value1}->class->box_kind == {v} && ((struct instance_{t.c_name}*){value1})->value == ((struct instance_{t.c_name}*){value2})->value)"
			end
			if s.is_empty then
				self.add("{res} = {value1} == {value2};")
				return res
			end
			test.add("({s.join(" || ")})")
		else
			self.add("{res} = {value1} == {value2};")
			return res
		end
		self.add("{res} = {value1} == {value2} || ({test.join(" && ")});")
		return res
	end

	fun can_be_primitive(value: RuntimeVariable): Bool
	do
		var t = value.mcasttype.undecorate
		if not t isa MClassType then return false
		var k = t.mclass.kind
		return k == interface_kind or t.is_c_primitive
	end

	redef fun array_instance(array, elttype)
	do
		var nclass = mmodule.native_array_class
		var arrayclass = mmodule.array_class
		var arraytype = arrayclass.get_mtype([elttype])
		var res = self.init_instance(arraytype)
		self.add("\{ /* {res} = array_instance Array[{elttype}] */")
		var length = self.int_instance(array.length)
		var nat = native_array_instance(elttype, length)
		for i in [0..array.length[ do
			var r = self.autobox(array[i], self.object_type)
			self.add("((struct instance_{nclass.c_name}*){nat})->values[{i}] = (val*) {r};")
		end
		self.send(self.get_property("with_native", arrayclass.intro.bound_mtype), [res, nat, length])
		self.add("\}")
		return res
	end

	redef fun native_array_instance(elttype, length)
	do
		var mtype = mmodule.native_array_type(elttype)
		self.require_declaration("NEW_{mtype.mclass.c_name}")
		assert mtype isa MGenericType
		var compiler = self.compiler
		length = autobox(length, compiler.mainmodule.int_type)
		if mtype.need_anchor then
			hardening_live_open_type(mtype)
			link_unresolved_type(self.frame.mpropdef.mclassdef, mtype)
			var recv = self.frame.arguments.first
			var recv_type_info = self.type_info(recv)
			self.require_declaration(mtype.const_color)
			return self.new_expr("NEW_{mtype.mclass.c_name}((int){length}, {recv_type_info}->resolution_table->types[{mtype.const_color}])", mtype)
		end
		compiler.undead_types.add(mtype)
		self.require_declaration("type_{mtype.c_name}")
		return self.new_expr("NEW_{mtype.mclass.c_name}((int){length}, &type_{mtype.c_name})", mtype)
	end

	redef fun native_array_def(pname, ret_type, arguments)
	do
		var elttype = arguments.first.mtype
		var nclass = mmodule.native_array_class
		var recv = "((struct instance_{nclass.c_name}*){arguments[0]})->values"
		if pname == "[]" then
			# Because the objects are boxed, return the box to avoid unnecessary (or broken) unboxing/reboxing
			var res = self.new_expr("{recv}[{arguments[1]}]", compiler.mainmodule.object_type)
			res.mcasttype = ret_type.as(not null)
			self.ret(res)
			return true
		else if pname == "[]=" then
			self.add("{recv}[{arguments[1]}]={arguments[2]};")
			return true
		else if pname == "length" then
			self.ret(self.new_expr("((struct instance_{nclass.c_name}*){arguments[0]})->length", ret_type.as(not null)))
			return true
		else if pname == "copy_to" then
			var recv1 = "((struct instance_{nclass.c_name}*){arguments[1]})->values"
			self.add("memmove({recv1}, {recv}, {arguments[2]}*sizeof({elttype.ctype}));")
			return true
		else if pname == "memmove" then
			# fun memmove(start: Int, length: Int, dest: NativeArray[E], dest_start: Int) is intern do
			var recv1 = "((struct instance_{nclass.c_name}*){arguments[3]})->values"
			self.add("memmove({recv1}+{arguments[4]}, {recv}+{arguments[1]}, {arguments[2]}*sizeof({elttype.ctype}));")
			return true
		end
		return false
	end

	redef fun native_array_get(nat, i)
	do
		var nclass = mmodule.native_array_class
		var recv = "((struct instance_{nclass.c_name}*){nat})->values"
		# Because the objects are boxed, return the box to avoid unnecessary (or broken) unboxing/reboxing
		var res = self.new_expr("{recv}[{i}]", compiler.mainmodule.object_type)
		return res
	end

	redef fun native_array_set(nat, i, val)
	do
		var nclass = mmodule.native_array_class
		var recv = "((struct instance_{nclass.c_name}*){nat})->values"
		self.add("{recv}[{i}]={val};")
	end

	redef fun routine_ref_instance(routine_type, recv, callsite)
	do
		#debug "ENTER ref_instance"
		var mmethoddef = callsite.mpropdef
		var mmethod = mmethoddef.mproperty
		# routine_mclass is the specialized one, e.g: FunRef1, ProcRef2, etc..
		var routine_mclass = routine_type.mclass

		var nclasses = mmodule.model.get_mclasses_by_name("RoutineRef").as(not null)
		var base_routine_mclass = nclasses.first

		# All routine classes use the same `NEW` constructor.
		# However, they have different declared `class` and `type` value.
		self.require_declaration("NEW_{base_routine_mclass.c_name}")

		var recv_class_cname = recv.mcasttype.as(MClassType).mclass.c_name
		var my_recv = recv

		if recv.mtype.is_c_primitive then
			my_recv = autobox(recv, mmodule.object_type)
		end
		var my_recv_mclass_type = my_recv.mtype.as(MClassType)

		# The class of the concrete Routine must exist (e.g ProcRef0, FunRef0, etc.)
		self.require_declaration("class_{routine_mclass.c_name}")
		self.require_declaration(mmethoddef.c_name)

		var thunk_function = mmethoddef.callref_thunk(my_recv_mclass_type)
		# If the receiver is exact, then there's no need to make a
		# polymorph call to the underlying method.
		thunk_function.polymorph_call_flag = not my_recv.is_exact
		var runtime_function = mmethoddef.virtual_runtime_function

		var is_c_equiv = runtime_function.msignature.c_equiv(thunk_function.msignature)

		var c_ref = thunk_function.c_ref
		if is_c_equiv then
			var const_color = mmethoddef.mproperty.const_color
			c_ref = "{class_info(my_recv)}->vft[{const_color}]"
			self.require_declaration(const_color)
		else
			self.require_declaration(thunk_function.c_name)
			compiler.thunk_todo(thunk_function)
		end
		var res: RuntimeVariable
		if routine_type.need_anchor then
			hardening_live_open_type(routine_type)
			link_unresolved_type(self.frame.mpropdef.mclassdef, routine_type)
			var recv2 = self.frame.arguments.first
			var recv2_type_info = self.type_info(recv2)
			self.require_declaration(routine_type.const_color)
			res = self.new_expr("NEW_{base_routine_mclass.c_name}({my_recv}, (nitmethod_t){c_ref}, &class_{routine_mclass.c_name}, {recv2_type_info}->resolution_table->types[{routine_type.const_color}])", routine_type)
		else
			self.require_declaration("type_{routine_type.c_name}")
			compiler.undead_types.add(routine_type)
			res = self.new_expr("NEW_{base_routine_mclass.c_name}({my_recv}, (nitmethod_t){c_ref}, &class_{routine_mclass.c_name}, &type_{routine_type.c_name})", routine_type)
		end
		return res
	end

	redef fun routine_ref_call(mmethoddef, arguments)
	do
		#debug "ENTER ref_call"
		compiler.modelbuilder.nb_invok_by_tables += 1
		if compiler.modelbuilder.toolcontext.opt_invocation_metrics.value then add("count_invoke_by_tables++;")
		var nclasses = mmodule.model.get_mclasses_by_name("RoutineRef").as(not null)
		var nclass = nclasses.first
		var runtime_function = mmethoddef.virtual_runtime_function

		# Save the current receiver since adapt_signature will autobox
		# the routine receiver which is not the underlying receiver.
		# The underlying receiver has already been adapted in the
		# `routine_ref_instance` method. Here we just want to adapt the
		# rest of the signature, but it's easier to pass the wrong
		# receiver in adapt_signature then discards it with `shift`.
		#
		# ~~~~nitish
		# class A; def toto do print "toto"; end
		# var a = new A
		# var f = &a.toto # `a` is the underlying receiver
		# f.call # here `f` is the routine receiver
		# ~~~~
		var routine = arguments.first

		# Retrieve the concrete routine type
		var original_recv_c = "(((struct instance_{nclass.c_name}*){arguments[0]})->recv)"
		var nitmethod = "(({runtime_function.c_funptrtype})(((struct instance_{nclass.c_name}*){arguments[0]})->method))"
		if arguments.length > 1 then
			adapt_signature(mmethoddef, arguments)
		end

		var ret_mtype = runtime_function.called_signature.return_mtype

		if ret_mtype != null then
			# `ret` is actually always nullable Object. When invoking
			# a callref, we don't have the original callsite information.
			# Thus, we need to recompute the return type of the callsite.
			ret_mtype = resolve_for(ret_mtype, routine)
		end

		# remove the routine's receiver
		arguments.shift
		var ss = arguments.join(", ")
		# replace the receiver with the original one
		if arguments.length > 0 then
			ss = "{original_recv_c}, {ss}"
		else
			ss = original_recv_c
		end

		arguments.unshift routine # put back the routine ref receiver
		add "/* {mmethoddef.mproperty} on {arguments.first.inspect}*/"
		var callsite = "{nitmethod}({ss})"
		if ret_mtype != null then
			var subres = new_expr("{callsite}", ret_mtype)
			ret(subres)
		else
			add("{callsite};")
		end
	end

	fun link_unresolved_type(mclassdef: MClassDef, mtype: MType) do
		assert mtype.need_anchor
		var compiler = self.compiler
		if not compiler.live_unresolved_types.has_key(self.frame.mpropdef.mclassdef) then
			compiler.live_unresolved_types[self.frame.mpropdef.mclassdef] = new HashSet[MType]
		end
		compiler.live_unresolved_types[self.frame.mpropdef.mclassdef].add(mtype)
	end
end