X-Git-Url: http://nitlanguage.org

diff --git a/src/model/model.nit b/src/model/model.nit
index b9d6aa2..d4ca515 100644
--- a/src/model/model.nit
+++ b/src/model/model.nit
@@ -30,6 +30,15 @@ import mdoc
 import ordered_tree
 private import more_collections
 
+redef class MEntity
+	# The visibility of the MEntity.
+	#
+	# MPackages, MGroups and MModules are always public.
+	# The visibility of `MClass` and `MProperty` is defined by the keyword used.
+	# `MClassDef` and `MPropDef` return the visibility of `MClass` and `MProperty`.
+	fun visibility: MVisibility do return public_visibility
+end
+
 redef class Model
 	# All known classes
 	var mclasses = new Array[MClass]
@@ -119,7 +128,17 @@ redef class Model
 	end
 end
 
-# An OrderedTree that can be easily refined for display purposes
+# An OrderedTree bound to MEntity.
+#
+# We introduce a new class so it can be easily refined by tools working
+# with a Model.
+class MEntityTree
+	super OrderedTree[MEntity]
+end
+
+# A MEntityTree borned to MConcern.
+#
+# TODO remove when nitdoc is fully merged with model_collect
 class ConcernsTree
 	super OrderedTree[MConcern]
 end
@@ -275,8 +294,9 @@ redef class MModule
 			if name == "Bool" and self.model.get_mclasses_by_name("Object") != null then
 				# Bool is injected because it is needed by engine to code the result
 				# of the implicit casts.
-				var c = new MClass(self, name, null, enum_kind, public_visibility)
-				var cladef = new MClassDef(self, c.mclass_type, new Location(null, 0,0,0,0))
+				var loc = model.no_location
+				var c = new MClass(self, name, loc, null, enum_kind, public_visibility)
+				var cladef = new MClassDef(self, c.mclass_type, loc)
 				cladef.set_supertypes([object_type])
 				cladef.add_in_hierarchy
 				return c
@@ -374,7 +394,9 @@ class MClass
 
 	# The short name of the class
 	# In Nit, the name of a class cannot evolve in refinements
-	redef var name: String
+	redef var name
+
+	redef var location
 
 	# The canonical name of the class
 	#
@@ -452,7 +474,7 @@ class MClass
 
 	# The visibility of the class
 	# In Nit, the visibility of a class cannot evolve in refinements
-	var visibility: MVisibility
+	redef var visibility
 
 	init
 	do
@@ -578,12 +600,13 @@ class MClassDef
 	# ENSURE: `bound_mtype.mclass == self.mclass`
 	var bound_mtype: MClassType
 
-	# The origin of the definition
-	var location: Location
+	redef var location: Location
+
+	redef fun visibility do return mclass.visibility
 
 	# Internal name combining the module and the class
-	# Example: "mymodule#MyClass"
-	redef var to_s: String is noinit
+	# Example: "mymodule$MyClass"
+	redef var to_s is noinit
 
 	init
 	do
@@ -594,34 +617,34 @@ class MClassDef
 			assert not isset mclass._intro
 			mclass.intro = self
 		end
-		self.to_s = "{mmodule}#{mclass}"
+		self.to_s = "{mmodule}${mclass}"
 	end
 
 	# Actually the name of the `mclass`
 	redef fun name do return mclass.name
 
-	# The module and class name separated by a '#'.
+	# The module and class name separated by a '$'.
 	#
 	# The short-name of the class is used for introduction.
-	# Example: "my_module#MyClass"
+	# Example: "my_module$MyClass"
 	#
 	# The full-name of the class is used for refinement.
-	# Example: "my_module#intro_module::MyClass"
+	# Example: "my_module$intro_module::MyClass"
 	redef var full_name is lazy do
 		if is_intro then
-			# public gives 'p#A'
-			# private gives 'p::m#A'
-			return "{mmodule.namespace_for(mclass.visibility)}#{mclass.name}"
+			# public gives 'p$A'
+			# private gives 'p::m$A'
+			return "{mmodule.namespace_for(mclass.visibility)}${mclass.name}"
 		else if mclass.intro_mmodule.mpackage != mmodule.mpackage then
-			# public gives 'q::n#p::A'
-			# private gives 'q::n#p::m::A'
-			return "{mmodule.full_name}#{mclass.full_name}"
+			# public gives 'q::n$p::A'
+			# private gives 'q::n$p::m::A'
+			return "{mmodule.full_name}${mclass.full_name}"
 		else if mclass.visibility > private_visibility then
-			# public gives 'p::n#A'
-			return "{mmodule.full_name}#{mclass.name}"
+			# public gives 'p::n$A'
+			return "{mmodule.full_name}${mclass.name}"
 		else
-			# private gives 'p::n#::m::A' (redundant p is omitted)
-			return "{mmodule.full_name}#::{mclass.intro_mmodule.name}::{mclass.name}"
+			# private gives 'p::n$::m::A' (redundant p is omitted)
+			return "{mmodule.full_name}$::{mclass.intro_mmodule.name}::{mclass.name}"
 		end
 	end
 
@@ -1155,6 +1178,8 @@ class MClassType
 
 	redef fun model do return self.mclass.intro_mmodule.model
 
+	redef fun location do return mclass.location
+
 	# TODO: private init because strongly bounded to its mclass. see `mclass.mclass_type`
 
 	# The formal arguments of the type
@@ -1277,7 +1302,7 @@ class MGenericType
 
 	# 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: String is noinit
+	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]]"`
@@ -1299,7 +1324,7 @@ class MGenericType
 		return res.to_s
 	end
 
-	redef var need_anchor: Bool is noinit
+	redef var need_anchor is noinit
 
 	redef fun resolve_for(mtype, anchor, mmodule, cleanup_virtual)
 	do
@@ -1360,6 +1385,8 @@ class MVirtualType
 	# Its the definitions of this property that determine the bound or the virtual type.
 	var mproperty: MVirtualTypeProp
 
+	redef fun location do return mproperty.location
+
 	redef fun model do return self.mproperty.intro_mclassdef.mmodule.model
 
 	redef fun lookup_bound(mmodule: MModule, resolved_receiver: MType): MType
@@ -1490,6 +1517,8 @@ class MParameterType
 
 	redef fun model do return self.mclass.intro_mmodule.model
 
+	redef fun location do return mclass.location
+
 	# The position of the parameter (0 for the first parameter)
 	# FIXME: is `position` a better name?
 	var rank: Int
@@ -1615,6 +1644,8 @@ abstract class MProxyType
 	# The base type
 	var mtype: MType
 
+	redef fun location do return mtype.location
+
 	redef fun model do return self.mtype.model
 	redef fun need_anchor do return mtype.need_anchor
 	redef fun as_nullable do return mtype.as_nullable
@@ -1669,7 +1700,7 @@ class MNullableType
 		self.to_s = "nullable {mtype}"
 	end
 
-	redef var to_s: String is noinit
+	redef var to_s is noinit
 
 	redef var full_name is lazy do return "nullable {mtype.full_name}"
 
@@ -1723,7 +1754,7 @@ end
 # The is only one null type per model, see `MModel::null_type`.
 class MNullType
 	super MType
-	redef var model: Model
+	redef var model
 	redef fun to_s do return "null"
 	redef fun full_name do return "null"
 	redef fun c_name do return "null"
@@ -1749,7 +1780,7 @@ end
 # Semantically it is the singleton `null.as_notnull`.
 class MBottomType
 	super MType
-	redef var model: Model
+	redef var model
 	redef fun to_s do return "bottom"
 	redef fun full_name do return "bottom"
 	redef fun c_name do return "bottom"
@@ -1885,7 +1916,7 @@ class MParameter
 	super MEntity
 
 	# The name of the parameter
-	redef var name: String
+	redef var name
 
 	# The static type of the parameter
 	var mtype: MType
@@ -1939,14 +1970,27 @@ abstract class MProperty
 	var intro_mclassdef: MClassDef
 
 	# The (short) name of the property
-	redef var name: String
+	redef var name
+
+	redef var location
 
 	# The canonical name of the property.
 	#
-	# It is the short-`name` prefixed by the short-name of the class and the full-name of the module.
+	# It is currently the short-`name` prefixed by the short-name of the class and the full-name of the module.
 	# Example: "my_package::my_module::MyClass::my_method"
+	#
+	# The full-name of the module is needed because two distinct modules of the same package can
+	# still refine the same class and introduce homonym properties.
+	#
+	# For public properties not introduced by refinement, the module name is not used.
+	#
+	# Example: `my_package::MyClass::My_method`
 	redef var full_name is lazy do
-		return "{intro_mclassdef.mmodule.namespace_for(visibility)}::{intro_mclassdef.mclass.name}::{name}"
+		if intro_mclassdef.is_intro then
+			return "{intro_mclassdef.mmodule.namespace_for(visibility)}::{intro_mclassdef.mclass.name}::{name}"
+		else
+			return "{intro_mclassdef.mmodule.full_name}::{intro_mclassdef.mclass.name}::{name}"
+		end
 	end
 
 	redef var c_name is lazy do
@@ -1955,7 +1999,7 @@ abstract class MProperty
 	end
 
 	# The visibility of the property
-	var visibility: MVisibility
+	redef var visibility
 
 	# Is the property usable as an initializer?
 	var is_autoinit = false is writable
@@ -2220,8 +2264,9 @@ abstract class MPropDef
 	# The associated global property
 	var mproperty: MPROPERTY
 
-	# The origin of the definition
-	var location: Location
+	redef var location: Location
+
+	redef fun visibility do return mproperty.visibility
 
 	init
 	do
@@ -2231,7 +2276,7 @@ abstract class MPropDef
 			assert not isset mproperty._intro
 			mproperty.intro = self
 		end
-		self.to_s = "{mclassdef}#{mproperty}"
+		self.to_s = "{mclassdef}${mproperty}"
 	end
 
 	# Actually the name of the `mproperty`
@@ -2245,17 +2290,17 @@ abstract class MPropDef
 	#  * 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"
+	#  * 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".
+	# 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"
+		# The first part is the mclassdef. Worst case is "r::o$q::n::B"
 		res.append mclassdef.full_name
 
-		res.append "#"
+		res.append "$"
 
 		if mclassdef.mclass == mproperty.intro_mclassdef.mclass then
 			# intro are unambiguous in a class
@@ -2264,7 +2309,7 @@ abstract class MPropDef
 			# 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.full_name
+				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,
@@ -2309,8 +2354,8 @@ abstract class MPropDef
 	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: String is noinit
+	# 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
@@ -2413,7 +2458,7 @@ end
 # Note this class is basically an enum.
 # FIXME: use a real enum once user-defined enums are available
 class MClassKind
-	redef var to_s: String
+	redef var to_s
 
 	# Is a constructor required?
 	var need_init: Bool