A definition of a property (local property)

# A definition of a property (local property)
#
# Unlike `MProperty`, a `MPropDef` is a local definition that belong to a
# specific class definition (which belong to a specific module)
abstract class MPropDef
	super MEntity

	# The associated `MProperty` subclass.
	# the two specialization hierarchy are symmetric
	type MPROPERTY: MProperty

	# Self class
	type MPROPDEF: MPropDef

	# The class definition where the property definition is
	var mclassdef: MClassDef

	# The associated global property
	var mproperty: MPROPERTY

	redef var location

	redef fun visibility do return mproperty.visibility

	init
	do
		mclassdef.mpropdefs.add(self)
		mproperty.mpropdefs.add(self)
		mclassdef.mpropdefs_by_property[mproperty] = self
		if mproperty.intro_mclassdef == mclassdef then
			assert not isset mproperty._intro
			mproperty.intro = self
		end
		self.to_s = "{mclassdef}${mproperty}"
	end

	# Actually the name of the `mproperty`
	redef fun name do return mproperty.name

	# The full-name of mpropdefs combine the information about the `classdef` and the `mproperty`.
	#
	# Therefore the combination of identifiers is awful,
	# the worst case being
	#
	#  * a property "p::m::A::x"
	#  * redefined in a refinement of a class "q::n::B"
	#  * in a module "r::o"
	#  * so "r::o$q::n::B$p::m::A::x"
	#
	# Fortunately, the full-name is simplified when entities are repeated.
	# For the previous case, the simplest form is "p$A$x".
	redef var full_name is lazy do
		var res = new FlatBuffer

		# The first part is the mclassdef. Worst case is "r::o$q::n::B"
		res.append mclassdef.full_name

		res.append "$"

		if mclassdef.mclass == mproperty.intro_mclassdef.mclass then
			# intro are unambiguous in a class
			res.append name
		else
			# Just try to simplify each part
			if mclassdef.mmodule.mpackage != mproperty.intro_mclassdef.mmodule.mpackage then
				# precise "p::m" only if "p" != "r"
				res.append mproperty.intro_mclassdef.mmodule.namespace_for(mproperty.visibility)
				res.append "::"
			else if mproperty.visibility <= private_visibility then
				# Same package ("p"=="q"), but private visibility,
				# does the module part ("::m") need to be displayed
				if mclassdef.mmodule.namespace_for(mclassdef.mclass.visibility) != mproperty.intro_mclassdef.mmodule.mpackage then
					res.append "::"
					res.append mproperty.intro_mclassdef.mmodule.name
					res.append "::"
				end
			end
			# precise "B" because it is not the same class than "A"
			res.append mproperty.intro_mclassdef.name
			res.append "::"
			# Always use the property name "x"
			res.append mproperty.name
		end
		return res.to_s
	end

	redef var c_name is lazy do
		var res = new FlatBuffer
		res.append mclassdef.c_name
		res.append "___"
		if mclassdef.mclass == mproperty.intro_mclassdef.mclass then
			res.append name.to_cmangle
		else
			if mclassdef.mmodule != mproperty.intro_mclassdef.mmodule then
				res.append mproperty.intro_mclassdef.mmodule.c_name
				res.append "__"
			end
			res.append mproperty.intro_mclassdef.name.to_cmangle
			res.append "__"
			res.append mproperty.name.to_cmangle
		end
		return res.to_s
	end

	redef fun model do return mclassdef.model

	# Internal name combining the module, the class and the property
	# Example: "mymodule$MyClass$mymethod"
	redef var to_s is noinit

	# Is self the definition that introduce the property?
	fun is_intro: Bool do return isset mproperty._intro and mproperty.intro == self

	# Return the next definition in linearization of `mtype`.
	#
	# This method is used to determine what method is called by a super.
	#
	# REQUIRE: `not mtype.need_anchor`
	fun lookup_next_definition(mmodule: MModule, mtype: MType): MPROPDEF
	do
		assert not mtype.need_anchor

		var mpropdefs = self.mproperty.lookup_all_definitions(mmodule, mtype)
		var i = mpropdefs.iterator
		while i.is_ok and i.item != self do i.next
		assert has_property: i.is_ok
		i.next
		assert has_next_property: i.is_ok
		return i.item
	end

	redef fun mdoc_or_fallback do return mdoc or else mproperty.mdoc_or_fallback

	# Does self have the `before` annotation?
	var is_before = false is writable

	# Does self have the `before_all` annotation?
	var is_before_all = false is writable

	# Does self have the `after` annotation?
	var is_after = false is writable

	# Does self have the `after_all` annotation?
	var is_after_all = false is writable
end

src/model/model.nit:2504,1--2648,3

nitc :: modelize_property $ MPropDef

redef class MPropDef
	# Does the MPropDef contains a call to super or a call of a super-constructor?
	# Subsequent phases of the frontend (esp. typing) set it if required
	var has_supercall: Bool = false is writable
end

src/modelize/modelize_property.nit:511,1--515,3

nitc :: neo $ MPropDef

redef class MPropDef
	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 = make_node(nodes, model_name)
		node.labels.add "MPropDef"
		node.out_edges.add(new NeoEdge(node, "DEFINES", mproperty.to_node(nodes, model_name)))
		node.labels.add self.class_name
		return node
	end
end

src/neo.nit:798,1--807,3

nitc :: abstract_compiler $ MPropDef

redef class MPropDef
	type VISITOR: AbstractCompilerVisitor
end

src/compiler/abstract_compiler.nit:2524,1--2526,3

nitc :: parse_annotations $ MPropDef

redef class MPropDef
	super AnnotatedMEntity

	redef var is_test is lazy do return has_annotation("test")

	redef var is_before is lazy do return has_annotation("before")

	redef var is_before_all is lazy do return has_annotation("before_all")

	redef var is_after is lazy do return has_annotation("after")

	redef var is_after_all is lazy do return has_annotation("after_all")
end

src/frontend/parse_annotations.nit:119,1--131,3

nitc :: astbuilder $ MPropDef

redef class MPropDef
	redef fun create_ast_representation(astbuilder: nullable ASTBuilder): APropdef is abstract
end

src/astbuilder.nit:956,1--958,3

nitc :: separate_compiler $ MPropDef

redef class MPropDef
	super PropertyLayoutElement
end

src/compiler/separate_compiler.nit:2652,1--2654,3

nitc :: model_collect $ MPropDef

redef class MPropDef

	redef fun collect_modifiers do
		var res = super
		if not is_intro then
			res.add "redef"
		else
			if mproperty.visibility != public_visibility then
				res.add mproperty.visibility.to_s
			end
		end
		var mprop = self
		if mprop isa MVirtualTypeDef then
			res.add "type"
		else if mprop isa MMethodDef then
			if mprop.is_abstract then
				res.add "abstract"
			else if mprop.is_intern then
				res.add "intern"
			end
			if mprop.mproperty.is_init then
				res.add "init"
			else
				res.add "fun"
			end
		else if mprop isa MAttributeDef then
			res.add "var"
		end
		return res
	end

	redef fun collect_linearization(mainmodule) do
		var mpropdefs = new Array[MPropDef]
		var mentity = self
		while not mentity.is_intro do
			mpropdefs.add mentity
			mentity = mentity.lookup_next_definition(mainmodule, mentity.mclassdef.bound_mtype)
		end
		mpropdefs.add mentity
		mainmodule.linearize_mpropdefs(mpropdefs)
		return mpropdefs
	end

	# Collect only the next definition of `self`
	redef fun collect_parents(mainmodule, filter) do
		var res = new HashSet[MENTITY]
		var mpropdef = self
		while not mpropdef.is_intro do
			mpropdef = mpropdef.lookup_next_definition(mclassdef.mmodule, mclassdef.bound_mtype)
			res.add mpropdef
		end
		return res
	end

	# Collect all children definitions that directly depend on `self`
	redef fun collect_children(mainmodule, filter) do
		var res = new HashSet[MENTITY]
		for mpropdef in mproperty.collect_mpropdefs(filter) do
			if mpropdef.collect_parents(mainmodule, filter).has(self) then res.add mpropdef
		end
		return res
	end
end

src/model/model_collect.nit:1117,1--1179,3

nitc :: contracts $ MPropDef

redef class MPropDef
	# flag to indicate is the `MPropDef` has a contract
	var has_contract = false
end

src/contracts.nit:765,1--768,3

nitc :: term_model $ MPropDef

redef class MPropDef
	redef fun cs_icon(no_color) do
		if is_intro then return visibility.cs_icon(no_color)
		return visibility.cs_visibility_color("*", no_color)
	end
end

src/doc/templates/term_model.nit:181,1--186,3

nitc :: model_index $ MPropDef

redef class MPropDef
	redef fun mentity_kind_rank do return 7
end

src/model/model_index.nit:670,1--672,3

nitc :: htmlight $ MPropDef

redef class MPropDef
	redef fun infobox(v)
	do
		var res = new HInfoBox(v, to_s)
		res.href = v.hrefto(self)
		if not v.show_infobox then return res
		if self isa MMethodDef then
			var msignature = self.msignature
			if msignature != null then res.new_field("fun").append(mproperty.name).add msignature.linkto(v)
		else if self isa MAttributeDef then
			var static_mtype = self.static_mtype
			if static_mtype != null then res.new_field("fun").append(mproperty.name).add static_mtype.linkto(v)
		else if self isa MVirtualTypeDef then
			var bound = self.bound
			if bound != null then res.new_field("add").append(mproperty.name).add bound.linkto(v)
		else
			res.new_field("wat?").append(mproperty.name)
		end

		if is_intro then
		else
			res.new_field("intro").add mproperty.intro.linkto_text(v, "in {mproperty.intro.mclassdef}")
		end
		add_doc_to_infobox(res)
		if mproperty.mpropdefs.length > 1 then
			var c = res.new_dropdown("redef", "redefinitions")
			for x in mproperty.mpropdefs do
				c.open("li").add x.linkto_text(v, "in {x.mclassdef}")
			end
		end

		return res
	end
end

src/htmlight.nit:540,1--573,3

nitc :: nitlight $ MPropDef

redef class MPropDef
	redef fun href(v)
	do
		var m = mclassdef.mmodule.href(v)
		if m == null then return null
		return m + "#" + to_s
	end
end

src/nitlight.nit:76,1--83,3

nitc :: html_model $ MPropDef

redef class MPropDef
	redef fun css_classes do return super + mproperty.css_classes

	redef fun html_namespace do
		var tpl = new Template
		tpl.add mclassdef.html_namespace
		tpl.add " :: "
		tpl.add html_link
		return tpl
	end

	redef fun html_icon do
		if is_intro then
			return new BSIcon("plus", css_classes)
		end
		return new BSIcon("asterisk", css_classes)
	end
end

src/doc/templates/html_model.nit:221,1--238,3

nitc :: json_model $ MPropDef

redef class MPropDef
	redef fun core_serialize_to(v) do
		super
		if is_intro then
			v.serialize_attribute("is_intro", true)
		end
	end

	redef fun json_namespace do
		var res = new JsonNamespace
		res.add_all mclassdef.json_namespace
		res.add "$"

		if mclassdef.mclass == mproperty.intro_mclassdef.mclass then
			res.add to_json_ref
		else
			if mclassdef.mmodule.mpackage != mproperty.intro_mclassdef.mmodule.mpackage then
				res.add_all mproperty.intro_mclassdef.mmodule.ns_for(mproperty.visibility)
				res.add "::"
			else if mproperty.visibility <= private_visibility then
				if mclassdef.mmodule.namespace_for(mclassdef.mclass.visibility) != mproperty.intro_mclassdef.mmodule.mpackage then
					res.add "::"
					res.add mproperty.intro_mclassdef.mmodule.to_json_ref
					res.add "::"
				end
			end
			if mclassdef.mclass != mproperty.intro_mclassdef.mclass then
				res.add mproperty.intro_mclassdef.to_json_ref
				res.add "::"
			end
			res.add to_json_ref
		end
		return res
	end
end

src/doc/templates/json_model.nit:247,1--281,3

nitc :: static_base $ MPropDef

redef class MPropDef
	redef var nitdoc_breadcrumbs is lazy do
		var res = new Array[MEntity].from(mclassdef.nitdoc_breadcrumbs)
		res.add self
		return res
	end
end

src/doc/static/static_base.nit:295,1--301,3

nitc :: static_html $ MPropDef

redef class MPropDef
	redef var html_url is lazy do
		if is_intro then return mproperty.html_url
		return "{mproperty.html_url}?def=def_code_{html_id}#lin"
	end
end

src/doc/static/static_html.nit:403,1--408,3

nitc :: api_base $ MPropDef

redef class MPropDef
	redef fun web_url do return "{mproperty.web_url}/lin#{full_name}"
end

src/doc/api/api_base.nit:197,1--199,3

abstract class MPropDef

Summary

A definition of a property (local property)

Introduced properties

MPROPDEF

MPROPERTY

VISITOR

_c_name

_full_name

_has_contract

_has_supercall

_html_url

_is_after

_is_after

_is_after_all

_is_after_all

_is_before

_is_before

_is_before_all

_is_before_all

_is_test

_location

_mclassdef

_mproperty

_nitdoc_breadcrumbs

_to_s

c_name=

defaultinit

full_name=

has_contract

has_contract=

has_supercall

has_supercall=

is_after

is_after=

is_after_all

is_after_all=

is_before

is_before=

is_before_all

is_before_all=

is_intro

location=

lookup_next_definition

mclassdef

mclassdef=

mproperty

mproperty=

nitdoc_breadcrumbs=

to_s=

Redefined properties

SELF

c_name

collect_children

collect_linearization

collect_modifiers

collect_parents

core_serialize_to

create_ast_representation

cs_icon

css_classes

full_name

href

html_icon

html_namespace

html_url

html_url=

infobox

init