redef class ASignature
	init init_asignature (
		n_opar: nullable TOpar,
		n_params: Collection[Object], # Should be Collection[AParam]
		n_cpar: nullable TCpar,
		n_type: nullable AType
	)
	do
		_n_opar = n_opar
		if n_opar != null then n_opar.parent = self
		self.n_params.unsafe_add_all(n_params)
		_n_cpar = n_cpar
		if n_cpar != null then n_cpar.parent = self
		_n_type = n_type
		if n_type != null then n_type.parent = self
	end

	redef fun replace_child(old_child: ANode, new_child: nullable ANode)
	do
		if _n_opar == old_child then
			n_opar = new_child.as(nullable TOpar)
			return
		end
		if n_params.replace_child(old_child, new_child) then return
		if _n_cpar == old_child then
			n_cpar = new_child.as(nullable TCpar)
			return
		end
		if _n_type == old_child then
			n_type = new_child.as(nullable AType)
			return
		end
	end

	redef fun n_opar=(node)
	do
		_n_opar = node
		if node != null then node.parent = self
	end
	redef fun n_cpar=(node)
	do
		_n_cpar = node
		if node != null then node.parent = self
	end
	redef fun n_type=(node)
	do
		_n_type = node
		if node != null then node.parent = self
	end


	redef fun visit_all(v: Visitor)
	do
		v.enter_visit(_n_opar)
		n_params.visit_all(v)
		v.enter_visit(_n_cpar)
		v.enter_visit(_n_type)
	end
end

redef class ASignature
	redef fun after_simple_misc(v)
	do
		if self.n_opar != null and self.n_params.is_empty then
			v.warning(self, "parentheses", "Warning: superfluous parentheses.")
		end
	end
end

redef class ASignature
	# Is the model builder has correctly visited the signature
	var is_visited = false
	# Names of parameters from the AST
	# REQUIRE: is_visited
	var param_names = new Array[String]
	# Types of parameters from the AST
	# REQUIRE: is_visited
	var param_types = new Array[MType]
	# Rank of the vararg (of -1 if none)
	# REQUIRE: is_visited
	var vararg_rank: Int = -1
	# Return type
	var ret_type: nullable MType = null

	# Visit and fill information about a signature
	private fun visit_signature(modelbuilder: ModelBuilder, mclassdef: MClassDef): Bool
	do
		var param_names = self.param_names
		var param_types = self.param_types
		for np in self.n_params do
			param_names.add(np.n_id.text)
			var ntype = np.n_type
			if ntype != null then
				var mtype = modelbuilder.resolve_mtype_unchecked(mclassdef, ntype, true)
				if mtype == null then return false # Skip error
				for i in [0..param_names.length-param_types.length[ do
					param_types.add(mtype)
				end
				if np.n_dotdotdot != null then
					if self.vararg_rank != -1 then
						modelbuilder.error(np, "Error: `{param_names[self.vararg_rank]}` is already a vararg")
						return false
					else
						self.vararg_rank = param_names.length - 1
					end
				end
			end
		end
		var ntype = self.n_type
		if ntype != null then
			self.ret_type = modelbuilder.resolve_mtype_unchecked(mclassdef, ntype, true)
			if self.ret_type == null then return false # Skip error
		end

		self.is_visited = true
		return true
	end

	private fun check_signature(modelbuilder: ModelBuilder, mclassdef: MClassDef): Bool
	do
		var res = true
		for np in self.n_params do
			var ntype = np.n_type
			if ntype != null then
				if modelbuilder.resolve_mtype(mclassdef, ntype) == null then
					res = false
				end
			end
		end
		var ntype = self.n_type
		if ntype != null then
			if modelbuilder.resolve_mtype(mclassdef, ntype) == null then
				res = false
			end
		end
		if not res then is_broken = true
		return res
	end
end

redef class ASignature
	redef fun accept_pretty_printer(v) do
		if not n_params.is_empty then
			v.consume "("
			v.visit_list n_params
			v.consume ")"
		end

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

redef class ASignature

	init make_from_msignature(msignature: MSignature)
	do
		var nparams = new Array[AParam]
		for mparam in msignature.mparameters do
			var variable = new Variable(mparam.name)
			variable.declared_type = mparam.mtype
			n_params.add(new AParam.make(variable, new AType.make(mparam.mtype)))
		end
		var return_type = null
		if msignature.return_mtype != null then return_type = new AType.make(msignature.return_mtype)
		init_asignature(null, nparams, null, return_type)
	end

	redef fun clone: SELF
	do
		var ntype = n_type
		if ntype != null then ntype = n_type.clone
		return new ASignature.init_asignature(null, n_params.clone, null, ntype)
	end
end

redef class ASignature

	# Create an array of AVarExpr representing the read of every parameters
	private fun make_parameter_read(ast_builder: ASTBuilder): Array[AVarExpr]
	do
		var args = new Array[AVarExpr]
		for n_param in self.n_params do
			var mtype = n_param.variable.declared_type
			var variable = n_param.variable
			if variable != null and mtype != null then
				args.push ast_builder.make_var_read(variable, mtype)
			end
		end
		return args
	end

	# Create a new ASignature adapted for contract
	#
	# The returned `ASignature` is the copy of `self` without return type.
	private fun adapt_to_contract: ASignature
	do
		var adapt_nsignature = self.clone
		if adapt_nsignature.n_type != null then adapt_nsignature.n_type.detach
		return adapt_nsignature
	end

	# Create a new ASignature adapted for ensure
	#
	# The returned `ASignature` is the copy of `self` without return type.
	# The return type is replaced by a new parameter `result`
	private fun adapt_to_ensurecondition: ASignature do
		var nsignature = adapt_to_contract
		if ret_type != null then
			var variable = new Variable("result")
			variable.declared_type = ret_type
			nsignature.n_params.add new AParam.make(variable, ret_type.create_ast_representation)
		end
		return nsignature
	end
end

redef class ASignature
	redef fun do_cloneable(v)
	do
		replace_clone
	end
end