redef class ACallrefExpr
	init init_acallrefexpr (
		n_amp: nullable TAmp,
		n_expr: nullable AExpr,
		n_qid: nullable AQid,
		n_args: nullable AExprs
	)
	do
		_n_amp = n_amp.as(not null)
		n_amp.parent = self
		_n_expr = n_expr.as(not null)
		n_expr.parent = self
		_n_qid = n_qid.as(not null)
		n_qid.parent = self
		_n_args = n_args.as(not null)
		n_args.parent = self
	end

	redef fun replace_child(old_child: ANode, new_child: nullable ANode)
	do
		if _n_amp == old_child then
			n_amp = new_child.as(TAmp)
			return
		end
		if _n_expr == old_child then
			n_expr = new_child.as(AExpr)
			return
		end
		if _n_qid == old_child then
			n_qid = new_child.as(AQid)
			return
		end
		if _n_args == old_child then
			n_args = new_child.as(AExprs)
			return
		end
	end

	redef fun n_amp=(node)
	do
		_n_amp = node
		node.parent = self
	end
	redef fun n_expr=(node)
	do
		_n_expr = node
		node.parent = self
	end
	redef fun n_qid=(node)
	do
		_n_qid = node
		node.parent = self
	end
	redef fun n_args=(node)
	do
		_n_args = node
		node.parent = self
	end


	redef fun visit_all(v: Visitor)
	do
		v.enter_visit(_n_amp)
		v.enter_visit(_n_expr)
		v.enter_visit(_n_qid)
		v.enter_visit(_n_args)
	end
end

redef class ACallrefExpr
	redef fun property_name do return n_qid.n_id.text
	redef fun property_node do return n_qid
	redef fun compute_raw_arguments do return n_args.to_a

	redef fun accept_typing(v)
	do
		super # do the job as if it was a real call
		var res = callsite.mproperty

                var msignature = callsite.mpropdef.msignature
                var recv = callsite.recv
                assert msignature != null
                var arity = msignature.mparameters.length

                var routine_type_name = "ProcRef"
                if msignature.return_mtype != null then
                        routine_type_name = "FunRef"
                end

                var target_routine_class = "{routine_type_name}{arity}"
                var routine_mclass = v.get_mclass(self, target_routine_class)

                if routine_mclass == null then
                        v.error(self, "Error: missing functional types, try `import functional`")
                        return
                end

                var types_list = new Array[MType]
                for param in msignature.mparameters do
                        if param.is_vararg then
                                types_list.push(v.mmodule.array_type(param.mtype))
                        else
                                types_list.push(param.mtype)
                        end
                end
                if msignature.return_mtype != null then
                        types_list.push(msignature.return_mtype.as(not null))
                end

                # Why we need an anchor :
                #
                # ~~~~nitish
                # class A[E]
                #       def toto(x: E) do print "{x}"
                # end
                #
                # var a = new A[Int]
                # var f = &a.toto # without anchor : ProcRef1[E]
                #		  # with anchor : ProcRef[Int]
                # ~~~~
		# However, we can only anchor if we can resolve every formal
		# parameter, here's an example where we can't.
		# ~~~~nitish
		# class A[E]
		#	fun bar: A[E] do return self
		#	fun foo: Fun0[A[E]] do return &bar # here we can't anchor
		# end
		# var f1 = a1.foo # when this expression will be evaluated,
		#		  # `a1` will anchor `&bar` returned by `foo`.
		# print f1.call
		# ~~~~
		var routine_type = routine_mclass.get_mtype(types_list)
		if not recv.need_anchor then
			routine_type = routine_type.anchor_to(v.mmodule, recv.as(MClassType))
		end
                is_typed = true
		self.mtype = routine_type
	end
end

redef class ACallrefExpr
        redef fun accept_rapid_type_visitor(v)
        do
                super
                v.add_type(mtype.as(MClassType))
        end
end

redef class ACallrefExpr
	redef fun expr(v)
	do
		var recv = v.expr(self.n_expr)
		if recv == null then return null
		var mtype = self.mtype
		assert mtype != null
		# In case we are in generic class where formal parameter can not
		# be resolved.
		var mtype2 = v.unanchor_type(mtype)
		var inst = new CallrefInstance(mtype2, recv, callsite.as(not null))
		return inst
	end
end

redef class ACallrefExpr
	redef fun expr(v)
	do
		var recv = v.expr(self.n_expr, null)
		var res = v.routine_ref_instance(mtype.as(MClassType), recv, callsite.as(not null))
		return res
	end
end