redef class AStdClassdef
	init init_astdclassdef (
		n_doc: nullable ADoc,
		n_kwredef: nullable TKwredef,
		n_visibility: nullable AVisibility,
		n_classkind: nullable AClasskind,
		n_qid: nullable AQclassid,
		n_obra: nullable TObra,
		n_formaldefs: Collection[Object], # Should be Collection[AFormaldef]
		n_cbra: nullable TCbra,
		n_extern_code_block: nullable AExternCodeBlock,
		n_propdefs: Collection[Object], # Should be Collection[APropdef]
		n_kwend: nullable TKwend
	)
	do
		_n_doc = n_doc
		if n_doc != null then n_doc.parent = self
		_n_kwredef = n_kwredef
		if n_kwredef != null then n_kwredef.parent = self
		_n_visibility = n_visibility.as(not null)
		n_visibility.parent = self
		_n_classkind = n_classkind.as(not null)
		n_classkind.parent = self
		_n_qid = n_qid
		if n_qid != null then n_qid.parent = self
		_n_obra = n_obra
		if n_obra != null then n_obra.parent = self
		self.n_formaldefs.unsafe_add_all(n_formaldefs)
		_n_cbra = n_cbra
		if n_cbra != null then n_cbra.parent = self
		_n_extern_code_block = n_extern_code_block
		if n_extern_code_block != null then n_extern_code_block.parent = self
		self.n_propdefs.unsafe_add_all(n_propdefs)
		_n_kwend = n_kwend.as(not null)
		n_kwend.parent = self
	end

	redef fun replace_child(old_child: ANode, new_child: nullable ANode)
	do
		if _n_doc == old_child then
			n_doc = new_child.as(nullable ADoc)
			return
		end
		if _n_kwredef == old_child then
			n_kwredef = new_child.as(nullable TKwredef)
			return
		end
		if _n_visibility == old_child then
			n_visibility = new_child.as(AVisibility)
			return
		end
		if _n_classkind == old_child then
			n_classkind = new_child.as(AClasskind)
			return
		end
		if _n_qid == old_child then
			n_qid = new_child.as(nullable AQclassid)
			return
		end
		if _n_obra == old_child then
			n_obra = new_child.as(nullable TObra)
			return
		end
		if n_formaldefs.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_extern_code_block == old_child then
			n_extern_code_block = new_child.as(nullable AExternCodeBlock)
			return
		end
		if n_propdefs.replace_child(old_child, new_child) then return
		if _n_kwend == old_child then
			n_kwend = new_child.as(TKwend)
			return
		end
	end

	redef fun n_doc=(node)
	do
		_n_doc = node
		if node != null then node.parent = self
	end
	redef fun n_kwredef=(node)
	do
		_n_kwredef = node
		if node != null then node.parent = self
	end
	redef fun n_visibility=(node)
	do
		_n_visibility = node
		node.parent = self
	end
	redef fun n_classkind=(node)
	do
		_n_classkind = node
		node.parent = self
	end
	redef fun n_qid=(node)
	do
		_n_qid = node
		if node != null then 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_extern_code_block=(node)
	do
		_n_extern_code_block = node
		if node != null then node.parent = self
	end
	redef fun n_kwend=(node)
	do
		_n_kwend = node
		node.parent = self
	end


	redef fun visit_all(v: Visitor)
	do
		v.enter_visit(_n_doc)
		v.enter_visit(_n_kwredef)
		v.enter_visit(_n_visibility)
		v.enter_visit(_n_classkind)
		v.enter_visit(_n_qid)
		v.enter_visit(_n_obra)
		n_formaldefs.visit_all(v)
		v.enter_visit(_n_cbra)
		v.enter_visit(_n_extern_code_block)
		n_propdefs.visit_all(v)
		v.enter_visit(_n_kwend)
	end
end

redef class AStdClassdef
	redef fun accept_pretty_printer(v) do
		v.visit n_doc
		var can_inline = v.can_inline(self)

		if not n_visibility isa APublicVisibility then
			v.visit n_visibility
			v.adds
		end

		if n_kwredef != null then
			v.visit n_kwredef
			v.adds
		end

		v.visit n_classkind
		v.adds
		v.visit n_qid

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

		if n_extern_code_block != null then
			v.adds
			v.visit n_extern_code_block
		end

		if can_inline then
			v.adds

			if not n_propdefs.is_empty then
				for n_superclass in n_propdefs do
					v.visit n_superclass
					v.adds
				end
			end
		else
			v.finish_line
			if v.skip_empty then v.addn
			v.indent += 1

			super
			v.catch_up n_kwend
			v.indent -= 1
		end

		v.visit n_kwend
		v.finish_line
		if v.skip_empty then v.addn
		assert v.indent == 0
	end

	redef fun is_inlinable do
		if not super then return false
		# FIXME: repair pretty-printing one-liner classes
		if n_propdefs.length > 0 then return false
		#if n_propdefs.length == 1 and not n_propdefs.first isa ASuperPropdef then return false
		if not collect_comments.is_empty then return false
		return true
	end

	redef fun start_token do
		if not n_visibility isa APublicVisibility then return n_visibility.first_token
		if n_kwredef != null then return n_kwredef
		return n_classkind.first_token
	end
end

redef class AStdClassdef
	private fun deserializer_npropdef: nullable AMethPropdef
	do
		for npropdef in n_propdefs do if npropdef isa AMethPropdef then
			var id = npropdef.n_methid
			if id isa AIdMethid and id.n_id.text == "deserialize_class_intern" then
				return npropdef
			end
		end

		return null
	end

	# Is this classed marked `serialize`? in part or fully?
	#
	# This method returns 3 possible values:
	# * `null`, this class is not to be serialized.
	# * `true`, the attributes of this class are to be serialized by default.
	# * `false`, the attributes of this class are to be serialized on demand only.
	fun how_serialize: nullable Bool
	do
		# Is there a declaration on the classdef or the module?
		var serialize = is_serialize

		if not serialize and not is_noserialize then
			# Is the module marked serialize?
			serialize = parent.as(AModule).is_serialize
		end

		if serialize then return true

		if not serialize then
			# Is there an attribute marked serialize?
			for npropdef in n_propdefs do
				if npropdef.is_serialize then
					return false
				end
			end
		end

		return null
	end
end

redef class AStdClassdef
	private init make(mclassdef: nullable MClassDef,
					n_visibility: nullable AVisibility,
					n_formaldefs : Collection[Object],
					n_extern_code_block : nullable AExternCodeBlock,
					n_propdefs : Collection[Object],
					n_classkind: nullable AClasskind)
	do
		if n_visibility == null then n_visibility = new APublicVisibility
		if n_classkind == null then n_classkind = new AConcreteClasskind.init_aconcreteclasskind(new TKwclass)
		var n_qid = new AQclassid.init_aqclassid(null, new TClassid)
		init_astdclassdef(null, null, n_visibility, n_classkind, n_qid, null, n_formaldefs, null, n_extern_code_block, n_propdefs, new TKwend)
		_mclassdef = mclassdef
		_mclass = mclassdef.mclass
	end
end

redef class AStdClassdef
	redef fun make_tag(v)
	do
		var res = new HTMLTag("span")
		res.add_class("nc_cdef")
		var md = mclassdef
		if md != null then res.attr("id", md.to_s)
		return res
	end
	redef fun decorate_tag(v, res, token)
	do
		if not token isa TClassid then return null
		res.add_class("nc_def")

		var md = mclassdef
		if md == null then return null
		return md.infobox(v)
	end
end