A type based on a generic class.

# A type based on a generic class.
# A generic type a just a class with additional formal generic arguments.
class MGenericType
	super MClassType

	redef var arguments

	# TODO: private init because strongly bounded to its mclass. see `mclass.get_mtype`

	init
	do
		assert self.mclass.arity == arguments.length

		self.need_anchor = false
		for t in arguments do
			if t.need_anchor then
				self.need_anchor = true
				break
			end
		end

		self.to_s = "{mclass}[{arguments.join(", ")}]"
	end

	# The short-name of the class, then the full-name of each type arguments within brackets.
	# Example: `"Map[String, List[Int]]"`
	redef var to_s is noinit

	# The full-name of the class, then the full-name of each type arguments within brackets.
	# Example: `"core::Map[core::String, core::List[core::Int]]"`
	redef var full_name is lazy do
		var args = new Array[String]
		for t in arguments do
			args.add t.full_name
		end
		return "{mclass.full_name}[{args.join(", ")}]"
	end

	redef var c_name is lazy do
		var res = mclass.c_name
		# Note: because the arity is known, a prefix notation is enough
		for t in arguments do
			res += "__"
			res += t.c_name
		end
		return res.to_s
	end

	redef var need_anchor is noinit

	redef fun resolve_for(mtype, anchor, mmodule, cleanup_virtual)
	do
		if not need_anchor then return self
		assert can_resolve_for(mtype, anchor, mmodule)
		var types = new Array[MType]
		for t in arguments do
			types.add(t.resolve_for(mtype, anchor, mmodule, cleanup_virtual))
		end
		return mclass.get_mtype(types)
	end

	redef fun can_resolve_for(mtype, anchor, mmodule)
	do
		if not need_anchor then return true
		for t in arguments do
			if not t.can_resolve_for(mtype, anchor, mmodule) then return false
		end
		return true
	end

	redef fun is_ok
	do
		for t in arguments do if not t.is_ok then return false
		return super
	end

	redef fun is_legal_in(mmodule, anchor)
	do
		var mtype
		if need_anchor then
			assert anchor != null
			mtype = anchor_to(mmodule, anchor)
		else
			mtype = self
		end
		if not mtype.is_ok then return false
		return mtype.is_subtype(mmodule, null, mtype.mclass.intro.bound_mtype)
	end

	redef fun depth
	do
		var dmax = 0
		for a in self.arguments do
			var d = a.depth
			if d > dmax then dmax = d
		end
		return dmax + 1
	end

	redef fun length
	do
		var res = 1
		for a in self.arguments do
			res += a.length
		end
		return res
	end
end

src/model/model.nit:1396,1--1503,3

nitc :: nitni_base $ MGenericType

redef class MGenericType
	redef fun mangled_cname
	do
		var base = super

		var params = new Array[String]
		for arg in arguments do params.add(arg.mangled_cname)

		return "{base}_of_{params.join("_")}"
	end
end

src/nitni/nitni_base.nit:146,1--156,3

nitc :: neo $ MGenericType

redef class MGenericType
	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 "MGenericType"
		return node
	end
end

src/neo.nit:894,1--901,3

nitc :: term_model $ MGenericType

redef class MGenericType
	redef fun cs_signature(no_color) do
		var tpl = new FlatBuffer
		tpl.append mclass.name
		tpl.append "["
		for i in [0..arguments.length[ do
			tpl.append arguments[i].cs_signature(no_color)
			if i < arguments.length - 1 then tpl.append ", "
		end
		tpl.append "]"
		return tpl.write_to_string
	end
end

src/doc/templates/term_model.nit:230,1--242,3

nitc :: uml_class $ MGenericType

redef class MGenericType
	redef fun tpl_class(model) do
		var t = new Template
		t.add name.substring(0, name.index_of('['))
		t.add "["
		t.add arguments.first.tpl_class(model)
		for i in [1 .. arguments.length[ do
			t.add ", "
			t.add arguments[i].tpl_class(model)
		end
		t.add "]"
		return t
	end
end

src/uml/uml_class.nit:180,1--193,3

nitc :: nitserial $ MGenericType

redef class MGenericType
	redef fun related_mclasses(mmodule)
	do
		var mods = super
		for arg_mtype in arguments do mods.add_all(arg_mtype.related_mclasses(mmodule))
		return mods
	end
end

src/nitserial.nit:72,1--79,3

nitc :: html_model $ MGenericType

redef class MGenericType
	redef fun html_signature(short) do
		var lnk = html_link
		var tpl = new Template
		tpl.add new Link(lnk.href, mclass.name.html_escape, lnk.title)
		tpl.add "["
		for i in [0..arguments.length[ do
			tpl.add arguments[i].html_signature(short)
			if i < arguments.length - 1 then tpl.add ", "
		end
		tpl.add "]"
		return tpl
	end
end

src/doc/templates/html_model.nit:292,1--305,3

class MGenericType

Summary

A type based on a generic class.

Introduced properties

_arguments

_c_name

_full_name

_need_anchor

_to_s

c_name=

defaultinit

full_name=

need_anchor=

to_s=

Redefined properties

SELF

arguments

arguments=

c_name

can_resolve_for

cs_signature

depth

full_name

html_signature

init

is_legal_in

is_ok

length

mangled_cname

need_anchor

related_mclasses

resolve_for

to_node

to_s

tpl_class

A type based on a generic class.

Introduced properties

private var _arguments: Array[MType]

private var _c_name: String

private var _full_name: String

private var _need_anchor: Bool

private var _to_s: String

protected fun c_name=(c_name: String)

init defaultinit(mclass: MClass, arguments: Array[MType])

protected fun full_name=(full_name: String)

protected fun need_anchor=(need_anchor: Bool)

protected fun to_s=(to_s: String)

Redefined properties

redef type SELF: MGenericType

redef fun arguments: Array[MType]

redef fun arguments=(arguments: Array[MType])

redef fun c_name: String

redef fun can_resolve_for(mtype: MType, anchor: nullable MClassType, mmodule: MModule): Bool

redef fun cs_signature(no_color: nullable Bool): String

redef fun depth: Int

redef fun full_name: String

redef fun html_signature(short: nullable Bool): Template

redef init init

redef fun is_legal_in(mmodule: MModule, anchor: nullable MClassType): Bool

redef fun is_ok: Bool

redef fun length: Int

redef fun mangled_cname: String

redef fun need_anchor: Bool

redef fun related_mclasses(mmodule: MModule): Array[MClass]

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

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

_api_url

_arguments

_arguments

_as_nullable_cache

_c_name