# A runtime function customized on a specific monomorph receiver type
private class CustomizedRuntimeFunction
	super AbstractRuntimeFunction

	redef type COMPILER: GlobalCompiler
	redef type VISITOR: GlobalCompilerVisitor

	# The considered reciever
	# (usually is a live type but no strong guarantee)
	var recv: MClassType

	redef fun build_c_name
	do
		var res = self.c_name_cache
		if res != null then return res
		if self.mmethoddef.mclassdef.bound_mtype == self.recv then
			res = self.mmethoddef.c_name
		else
			res = "{mmethoddef.c_name}__{recv.c_name}"
		end
		self.c_name_cache = res
		return res
	end

	# used in the compiler worklist
	redef fun ==(o)
	do
		if not o isa CustomizedRuntimeFunction then return false
		if self.mmethoddef != o.mmethoddef then return false
		if self.recv != o.recv then return false
		return true
	end

	# used in the compiler work-list
	redef fun hash do return self.mmethoddef.hash + self.recv.hash

	redef fun to_s
	do
		if self.mmethoddef.mclassdef.bound_mtype == self.recv then
			return self.mmethoddef.to_s
		else
			return "{self.mmethoddef}@{self.recv}"
		end
	end

        redef fun recv_mtype
        do
                return recv
        end

        redef var return_mtype

        redef fun resolve_receiver(v)
        do
                var selfvar = new RuntimeVariable("self", recv, recv)
		if v.compiler.runtime_type_analysis.live_types.has(recv) then
			selfvar.is_exact = true
		end
                return selfvar
        end

        redef fun resolve_return_mtype(v)
        do
                var selfvar = v.frame.selfvar
                if has_return then
                        var ret = msignature.return_mtype.as(not null)
                        return_mtype = v.resolve_for(ret, selfvar)
                end
        end
        redef fun resolve_ith_parameter(v, i)
        do
                var selfvar = v.frame.selfvar
                var mp = msignature.mparameters[i]
                var mtype = mp.mtype
                if mp.is_vararg then
                        mtype = v.mmodule.array_type(mtype)
                end
                mtype = v.resolve_for(mtype, selfvar)
                return new RuntimeVariable("p{i}", mtype, mtype)
        end

        redef fun declare_signature(v, sig)
        do
                v.compiler.header.add_decl("{sig};")
        end

        redef fun end_compile_to_c(v)
        do
	        if not self.c_name.has_substring("VIRTUAL", 0) then v.compiler.names[self.c_name] = "{mmethoddef.mclassdef.mmodule.name}::{mmethoddef.mclassdef.mclass.name}::{mmethoddef.mproperty.name} ({mmethoddef.location.file.filename}:{mmethoddef.location.line_start})"
        end

	redef fun call(v: VISITOR, arguments: Array[RuntimeVariable]): nullable RuntimeVariable
	do
		var ret = self.mmethoddef.msignature.return_mtype
		if ret != null then
			ret = v.resolve_for(ret, arguments.first)
		end

                # TODO: remove this guard when gcc warning issue (#2781) is resolved
                # WARNING: the next two lines of code is used to prevent inlining.
                # Inlining of a callref seems to work all the time. However,
                # it will produce some deadcode in certain scenarios (when using nullable type).
                #
                # ~~~~nitish
                # class A[E]
                #       fun toto(x: E)
                #       do
                #               # ...do something with x...
                #       end
                # end
                # end
                # var a = new A[nullable Int]
                # var f = &a.toto
                # f.call(null)  # Will produce a proper C callsite, but it will
                #               # produce unreachable (dead code) for type checking
                #               # and covariance. Thus, creating warnings when
                #               # compiling in global. However, if you ignore
                #               # those warnings, the binary works perfectly fine.
                # ~~~~
                var intromclassdef = self.mmethoddef.mproperty.intro_mclassdef
                var is_callref = v.compiler.all_routine_types_name.has(intromclassdef.name)

                if self.mmethoddef.can_inline(v) and not is_callref then
			var frame = new StaticFrame(v, self.mmethoddef, self.recv, arguments)
			frame.returnlabel = v.get_name("RET_LABEL")
			if ret != null then
				frame.returnvar = v.new_var(ret)
			end
			var old_frame = v.frame
			v.frame = frame
			v.add("\{ /* Inline {self} ({arguments.join(",")}) */")
			self.mmethoddef.compile_inside_to_c(v, arguments)
			v.add("{frame.returnlabel.as(not null)}:(void)0;")
			v.add("\}")
			v.frame = old_frame
			return frame.returnvar
		end
		v.adapt_signature(self.mmethoddef, arguments)
		v.compiler.todo(self)
		if ret == null then
			v.add("{self.c_name}({arguments.join(",")});")
			return null
		else
			var res = v.new_var(ret)
			v.add("{res} = {self.c_name}({arguments.join(",")});")
			return res
		end
	end
end