redef class AType
	init init_atype (
		n_kwnullable: nullable TKwnullable,
		n_qid: nullable AQclassid,
		n_obra: nullable TObra,
		n_types: Collection[Object], # Should be Collection[AType]
		n_cbra: nullable TCbra,
		n_annotations: nullable AAnnotations
	)
	do
		_n_kwnullable = n_kwnullable
		if n_kwnullable != null then n_kwnullable.parent = self
		_n_qid = n_qid.as(not null)
		n_qid.parent = self
		_n_obra = n_obra
		if n_obra != null then n_obra.parent = self
		self.n_types.unsafe_add_all(n_types)
		_n_cbra = n_cbra
		if n_cbra != null then n_cbra.parent = self
		_n_annotations = n_annotations
		if n_annotations != null then n_annotations.parent = self
	end

	redef fun replace_child(old_child: ANode, new_child: nullable ANode)
	do
		if _n_kwnullable == old_child then
			n_kwnullable = new_child.as(nullable TKwnullable)
			return
		end
		if _n_qid == old_child then
			n_qid = new_child.as(AQclassid)
			return
		end
		if _n_obra == old_child then
			n_obra = new_child.as(nullable TObra)
			return
		end
		if n_types.replace_child(old_child, new_child) then return
		if _n_cbra == old_child then
			n_cbra = new_child.as(nullable TCbra)
			return
		end
		if _n_annotations == old_child then
			n_annotations = new_child.as(nullable AAnnotations)
			return
		end
	end

	redef fun n_kwnullable=(node)
	do
		_n_kwnullable = node
		if node != null then node.parent = self
	end
	redef fun n_qid=(node)
	do
		_n_qid = node
		node.parent = self
	end
	redef fun n_obra=(node)
	do
		_n_obra = node
		if node != null then node.parent = self
	end
	redef fun n_cbra=(node)
	do
		_n_cbra = node
		if node != null then node.parent = self
	end
	redef fun n_annotations=(node)
	do
		_n_annotations = node
		if node != null then node.parent = self
	end


	redef fun visit_all(v: Visitor)
	do
		v.enter_visit(_n_kwnullable)
		v.enter_visit(_n_qid)
		v.enter_visit(_n_obra)
		n_types.visit_all(v)
		v.enter_visit(_n_cbra)
		v.enter_visit(_n_annotations)
	end
end

redef class AType
	# The mtype associated to the node
	var mtype: nullable MType = null

	# Is the mtype a valid one?
	var checked_mtype: Bool = false

	redef fun dump_info(v) do
		var res = super
		var mtype = self.mtype
		if mtype != null then
			res += v.yellow(":{mtype}")
		end
		return res
	end
end

redef class AType
	private fun type_name: String
	do
		var name = n_qid.n_id.text

		if n_kwnullable != null then name = "nullable {name}"

		var types = n_types
		if not types.is_empty then
			var params = new Array[String]
			for t in types do params.add(t.type_name)
			return "{name}[{params.join(", ")}]"
		else return name
	end
end

redef class AType
	redef fun accept_pretty_printer(v) do
		if n_kwnullable != null then
			v.visit n_kwnullable
			v.adds
		end

		v.visit n_qid

		if not n_types.is_empty then
			v.consume "["
			v.visit_list n_types
			v.consume "]"
		end
	end
end

redef class AType

	private init make(t: nullable MType)
	do
		var n_id = new TClassid
		var n_qid = new AQclassid
		n_qid.n_id = n_id
		_n_qid = n_qid
		_mtype = t
	end

	redef fun clone: SELF
	do
		return new AType.make(mtype)
	end
end

redef class AType
	redef fun decorate_tag(v, res, token)
	do
		if not token isa TClassid then return null
		var mt = mtype
		if mt == null then return null
		mt = mt.undecorate
		if mt isa MFormalType then
			res.add_class("nc_vt")
		end
		return mt.infobox(v)
	end
end