A signature of a method

# A signature of a method
class MSignature
	super MType

	# The each parameter (in order)
	var mparameters: Array[MParameter]

	# Returns a parameter named `name`, if any.
	fun mparameter_by_name(name: String): nullable MParameter
	do
		for p in mparameters do
			if p.name == name then return p
		end
		return null
	end

	# The return type (null for a procedure)
	var return_mtype: nullable MType

	redef fun depth
	do
		var dmax = 0
		var t = self.return_mtype
		if t != null then dmax = t.depth
		for p in mparameters do
			var d = p.mtype.depth
			if d > dmax then dmax = d
		end
		return dmax + 1
	end

	redef fun length
	do
		var res = 1
		var t = self.return_mtype
		if t != null then res += t.length
		for p in mparameters do
			res += p.mtype.length
		end
		return res
	end

	# REQUIRE: 1 <= mparameters.count p -> p.is_vararg
	init
	do
		var vararg_rank = -1
		for i in [0..mparameters.length[ do
			var parameter = mparameters[i]
			if parameter.is_vararg then
				if vararg_rank >= 0 then
					# If there is more than one vararg,
					# consider that additional arguments cannot be mapped.
					vararg_rank = -1
					break
				end
				vararg_rank = i
			end
		end
		self.vararg_rank = vararg_rank
	end

	# The rank of the main ellipsis (`...`) for vararg (starting from 0).
	# value is -1 if there is no vararg.
	# Example: for "(a: Int, b: Bool..., c: Char)" #-> vararg_rank=1
	#
	# From a model POV, a signature can contain more than one vararg parameter,
	# the `vararg_rank` just indicates the one that will receive the additional arguments.
	# However, currently, if there is more that one vararg parameter, no one will be the main one,
	# and additional arguments will be refused.
	var vararg_rank: Int is noinit

	# The number of parameters
	fun arity: Int do return mparameters.length

	redef fun to_s
	do
		var b = new FlatBuffer
		if not mparameters.is_empty then
			b.append("(")
			var last_mtype = null
			for i in [0..mparameters.length[ do
				var mparameter = mparameters[i]

				# Group types that are common to contiguous parameters
				if mparameter.mtype != last_mtype and last_mtype != null then
					b.append(": ")
					b.append(last_mtype.to_s)
				end

				if i > 0 then b.append(", ")
				b.append(mparameter.name)

				if mparameter.is_vararg then
					b.append(": ")
					b.append(mparameter.mtype.to_s)
					b.append("...")
					last_mtype = null
				else
					last_mtype = mparameter.mtype
				end
			end

			if last_mtype != null then
				b.append(": ")
				b.append(last_mtype.to_s)
			end

			b.append(")")
		end
		var ret = self.return_mtype
		if ret != null then
			b.append(": ")
			b.append(ret.to_s)
		end
		return b.to_s
	end

	redef fun resolve_for(mtype: MType, anchor: nullable MClassType, mmodule: MModule, cleanup_virtual: Bool): MSignature
	do
		var params = new Array[MParameter]
		for p in self.mparameters do
			params.add(p.resolve_for(mtype, anchor, mmodule, cleanup_virtual))
		end
		var ret = self.return_mtype
		if ret != null then
			ret = ret.resolve_for(mtype, anchor, mmodule, cleanup_virtual)
		end
		var res = new MSignature(params, ret)
		return res
	end
end

src/model/model.nit:1964,1--2094,3

nitc :: neo $ MSignature

redef class MSignature
	redef fun to_node(nodes: HashMap[MEntity, NeoNode], model_name: nullable String): NeoNode do
		if nodes.has_key(self) then return nodes[self]
		var node = super
		node.labels.add "MSignature"
		var names = new JsonArray
		var rank = 0
		for mparameter in mparameters do
			names.add mparameter.name
			var pnode = mparameter.to_node(nodes, model_name)
			pnode["rank"] = rank
			node.out_edges.add(new NeoEdge(node, "PARAMETER", pnode))
			rank += 1
		end
		if not names.is_empty then node["parameter_names"] = names
		var return_mtype = return_mtype
		if return_mtype != null then
			node.out_edges.add(new NeoEdge(node, "RETURNTYPE", return_mtype.to_node(nodes, model_name)))
		end
		return node
	end
end

src/neo.nit:934,1--955,3

nitc :: astbuilder $ MSignature

redef class MSignature
	redef fun create_ast_representation(astbuilder: nullable ASTBuilder): ASignature do
		var nparams = new Array[AParam]
		for mparam in mparameters do nparams.add(mparam.create_ast_representation(astbuilder))
		var return_type = null
		if self.return_mtype != null then return_type = self.return_mtype.create_ast_representation(astbuilder)
		return new ASignature.init_asignature(null, nparams, null, return_type)
	end
end

src/astbuilder.nit:1018,1--1026,3

nitc :: term_model $ MSignature

redef class MSignature
	redef fun cs_signature(no_color) do
		var tpl = new FlatBuffer
		if not mparameters.is_empty then
			tpl.append "("
			for i in [0..mparameters.length[ do
				tpl.append mparameters[i].cs_signature(no_color)
				if i < mparameters.length - 1 then tpl.append ", "
			end
			tpl.append ")"
		end
		var return_mtype = self.return_mtype
		if return_mtype != null then
			tpl.append ": "
			tpl.append return_mtype.cs_signature(no_color)
		end
		return tpl.write_to_string
	end
end

src/doc/templates/term_model.nit:252,1--270,3

nitc :: uml_class $ MSignature

redef class MSignature

	redef fun tpl_class(model) do
		var t = new Template
		t.add "("
		var params = new Array[MParameter]
		for i in mparameters do
			params.add i
		end
		if params.length > 0 then
			t.add params.first.name.escape_to_dot
			t.add ": "
			t.add params.first.mtype.tpl_class(model)
			for i in [1 .. params.length [ do
				t.add ", "
				t.add params[i].name.escape_to_dot
				t.add ": "
				t.add params[i].mtype.tpl_class(model)
			end
		end
		t.add ")"
		if return_mtype != null then
			t.add ": "
			t.add return_mtype.tpl_class(model)
		end
		return t
	end
end

src/uml/uml_class.nit:115,1--142,3

nitc :: contracts $ MSignature

redef class MSignature

	# Adapt signature for an contract
	#
	# The returned `MSignature` is the copy of `self` without return type.
	private fun adapt_to_contract: MSignature do return new MSignature(mparameters.to_a, null)

	# Adapt signature for a ensure contract
	#
	# The returned `MSignature` is the copy of `self` without return type.
	# The return type is replaced by a new parameter `result`
	private fun adapt_to_ensurecondition: MSignature
	do
		var rtype = return_mtype
		var msignature = adapt_to_contract
		if rtype != null then
			msignature.mparameters.add(new MParameter("result", rtype, false))
		end
		return msignature
	end

	# The returned `MSignature` is the exact copy of `self`.
	private fun clone: MSignature do return new MSignature(mparameters.to_a, return_mtype)
end

src/contracts.nit:767,1--790,3

nitc :: htmlight $ MSignature

redef class MSignature
	redef fun linkto(v)
	do
		var res = new HTMLTag("span")
		var first = true
		if not mparameters.is_empty then
			res.append "("
			for p in mparameters do
				if first then
					first = false
				else
					res.append ", "
				end
				res.append p.name
				res.append ": "
				res.add p.mtype.linkto(v)
			end
			res.append ")"
		end
		var ret = return_mtype
		if ret != null then
			res.append ": "
			res.add ret.linkto(v)
		end
		return res
	end
end

src/htmlight.nit:656,1--682,3

nitc :: html_model $ MSignature

redef class MSignature
	redef fun html_signature(short) do
		var tpl = new Template
		if not mparameters.is_empty then
			tpl.add "("
			for i in [0..mparameters.length[ do
				tpl.add mparameters[i].html_signature(short)
				if i < mparameters.length - 1 then tpl.add ", "
			end
			tpl.add ")"
		end
		if short == null or not short then
			var return_mtype = self.return_mtype
			if return_mtype != null then
				tpl.add ": "
				tpl.add return_mtype.html_signature(short)
			end
		end
		return tpl
	end
end

src/doc/templates/html_model.nit:319,1--339,3

nitc :: separate_compiler $ MSignature

redef class MSignature
	# Does the C-version of `self` the same than the C-version of `other`?
	fun c_equiv(other: MSignature): Bool
	do
		if self == other then return true
		if arity != other.arity then return false
		for i in [0..arity[ do
			if mparameters[i].mtype.ctype != other.mparameters[i].mtype.ctype then return false
		end
		if return_mtype != other.return_mtype then
			if return_mtype == null or other.return_mtype == null then return false
			if return_mtype.ctype != other.return_mtype.ctype then return false
		end
		return true
	end
end

src/compiler/separate_compiler.nit:2446,1--2461,3

nitc :: json_model $ MSignature

redef class MSignature
	redef fun core_serialize_to(v) do
		v.serialize_attribute("arity", arity)
		v.serialize_attribute("mparameters", mparameters)
		v.serialize_attribute("return_mtype", return_mtype)
	end
end

src/doc/templates/json_model.nit:317,1--323,3

class MSignature

Summary

A signature of a method

Introduced properties

_mparameters

_return_mtype

_vararg_rank

adapt_to_contract

adapt_to_ensurecondition

arity

c_equiv

clone

defaultinit

mparameter_by_name

mparameters

mparameters=

return_mtype

return_mtype=

vararg_rank

vararg_rank=

Redefined properties

SELF

core_serialize_to

create_ast_representation

cs_signature

depth

html_signature

init

length

linkto

resolve_for

to_node

to_s

tpl_class

A signature of a method

Introduced properties

private var _mparameters: Array[MParameter]

private var _return_mtype: nullable MType

private var _vararg_rank: Int

private fun adapt_to_contract: MSignature

private fun adapt_to_ensurecondition: MSignature

fun arity: Int

fun c_equiv(other: MSignature): Bool

private fun clone: MSignature

init defaultinit(mparameters: Array[MParameter], return_mtype: nullable MType)

fun mparameter_by_name(name: String): nullable MParameter

fun mparameters: Array[MParameter]

protected fun mparameters=(mparameters: Array[MParameter])

fun return_mtype: nullable MType

protected fun return_mtype=(return_mtype: nullable MType)

fun vararg_rank: Int

protected fun vararg_rank=(vararg_rank: Int)

Redefined properties

redef type SELF: MSignature

redef fun core_serialize_to(v: Serializer)

redef fun create_ast_representation(astbuilder: nullable ASTBuilder): ASignature

redef fun cs_signature(no_color: nullable Bool): String

redef fun depth: Int

redef fun html_signature(short: nullable Bool): Template

redef init init

redef fun length: Int

redef fun linkto(v: HtmlightVisitor): HTMLTag

redef fun resolve_for(mtype: MType, anchor: nullable MClassType, mmodule: MModule, cleanup_virtual: Bool): MSignature

redef fun to_node(nodes: HashMap[MEntity, NeoNode], model_name: nullable String): NeoNode

redef fun to_s: String

redef fun tpl_class(model: UMLModel): Writable

Summary

All properties

!=

==

CLASS

MENTITY

SELF

_as_nullable_cache

_const_color

_css_classes

_deprecation

_examples

_html_full_name

_html_id