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

diff --git a/src/model/model.nit b/src/model/model.nit
index 54c9edb..3d9a364 100644
--- a/src/model/model.nit
+++ b/src/model/model.nit
@@ -119,7 +119,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
@@ -206,6 +216,24 @@ redef class MModule
 	# The primitive type `Int`
 	var int_type: MClassType = self.get_primitive_class("Int").mclass_type is lazy
 
+	# The primitive type `Byte`
+	var byte_type: MClassType = self.get_primitive_class("Byte").mclass_type is lazy
+
+	# The primitive type `Int8`
+	var int8_type: MClassType = self.get_primitive_class("Int8").mclass_type is lazy
+
+	# The primitive type `Int16`
+	var int16_type: MClassType = self.get_primitive_class("Int16").mclass_type is lazy
+
+	# The primitive type `UInt16`
+	var uint16_type: MClassType = self.get_primitive_class("UInt16").mclass_type is lazy
+
+	# The primitive type `Int32`
+	var int32_type: MClassType = self.get_primitive_class("Int32").mclass_type is lazy
+
+	# The primitive type `UInt32`
+	var uint32_type: MClassType = self.get_primitive_class("UInt32").mclass_type is lazy
+
 	# The primitive type `Char`
 	var char_type: MClassType = self.get_primitive_class("Char").mclass_type is lazy
 
@@ -251,21 +279,25 @@ redef class MModule
 	fun get_primitive_class(name: String): MClass
 	do
 		var cla = self.model.get_mclasses_by_name(name)
-		if cla == null then
+		# Filter classes by introducing module
+		if cla != null then cla = [for c in cla do if self.in_importation <= c.intro_mmodule then c]
+		if cla == null or cla.is_empty then
 			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
 			end
-			print("Fatal Error: no primitive class {name}")
+			print("Fatal Error: no primitive class {name} in {self}")
 			exit(1)
+			abort
 		end
 		if cla.length != 1 then
-			var msg = "Fatal Error: more than one primitive class {name}:"
+			var msg = "Fatal Error: more than one primitive class {name} in {self}:"
 			for c in cla do msg += " {c.full_name}"
 			print msg
 			#exit(1)
@@ -279,18 +311,15 @@ redef class MModule
 		var props = self.model.get_mproperties_by_name(name)
 		if props == null then return null
 		var res: nullable MMethod = null
+		var recvtype = recv.intro.bound_mtype
 		for mprop in props do
 			assert mprop isa MMethod
-			var intro = mprop.intro_mclassdef
-			for mclassdef in recv.mclassdefs do
-				if not self.in_importation.greaters.has(mclassdef.mmodule) then continue
-				if not mclassdef.in_hierarchy.greaters.has(intro) then continue
-				if res == null then
-					res = mprop
-				else if res != mprop then
-					print("Fatal Error: ambigous property name '{name}'; conflict between {mprop.full_name} and {res.full_name}")
-					abort
-				end
+			if not recvtype.has_mproperty(self, mprop) then continue
+			if res == null then
+				res = mprop
+			else if res != mprop then
+				print("Fatal Error: ambigous property name '{name}'; conflict between {mprop.full_name} and {res.full_name}")
+				abort
 			end
 		end
 		return res
@@ -356,7 +385,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
 	#
@@ -378,6 +409,29 @@ class MClass
 	# is empty if the class is not generic
 	var mparameters = new Array[MParameterType]
 
+	# A string version of the signature a generic class.
+	#
+	# eg. `Map[K: nullable Object, V: nullable Object]`
+	#
+	# If the class in non generic the name is just given.
+	#
+	# eg. `Object`
+	fun signature_to_s: String
+	do
+		if arity == 0 then return name
+		var res = new FlatBuffer
+		res.append name
+		res.append "["
+		for i in [0..arity[ do
+			if i > 0 then res.append ", "
+			res.append mparameters[i].name
+			res.append ": "
+			res.append intro.bound_mtype.arguments[i].to_s
+		end
+		res.append "]"
+		return res.to_s
+	end
+
 	# Initialize `mparameters` from their names.
 	protected fun setup_parameter_names(parameter_names: nullable Array[String]) is
 		autoinit
@@ -433,8 +487,17 @@ class MClass
 	#
 	# Warning: such a definition may not exist in the early life of the object.
 	# In this case, the method will abort.
+	#
+	# Use `try_intro` instead
 	var intro: MClassDef is noinit
 
+	# The definition that introduces the class or null if not yet known.
+	#
+	# See `intro`
+	fun try_intro: nullable MClassDef do
+		if isset _intro then return _intro else return null
+	end
+
 	# Return the class `self` in the class hierarchy of the module `mmodule`.
 	#
 	# SEE: `MModule::flatten_mclass_hierarchy`
@@ -480,6 +543,20 @@ class MClass
 
 	# Is there a `new` factory to allow the pseudo instantiation?
 	var has_new_factory = false is writable
+
+	# Is `self` a standard or abstract class kind?
+	var is_class: Bool is lazy do return kind == concrete_kind or kind == abstract_kind
+
+	# Is `self` an interface kind?
+	var is_interface: Bool is lazy do return kind == interface_kind
+
+	# Is `self` an enum kind?
+	var is_enum: Bool is lazy do return kind == enum_kind
+
+	# Is `self` and abstract class?
+	var is_abstract: Bool is lazy do return kind == abstract_kind
+
+	redef fun mdoc_or_fallback do return intro.mdoc_or_fallback
 end
 
 
@@ -516,12 +593,11 @@ class MClassDef
 	# ENSURE: `bound_mtype.mclass == self.mclass`
 	var bound_mtype: MClassType
 
-	# The origin of the definition
-	var location: Location
+	redef var location: Location
 
 	# 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
@@ -532,41 +608,41 @@ 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}"
-		else if mclass.intro_mmodule.mproject != mmodule.mproject then
-			# public gives 'q::n#p::A'
-			# private gives 'q::n#p::m::A'
-			return "{mmodule.full_name}#{mclass.full_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}"
 		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
 
 	redef var c_name is lazy do
 		if is_intro then
 			return "{mmodule.c_namespace_for(mclass.visibility)}___{mclass.c_name}"
-		else if mclass.intro_mmodule.mproject == mmodule.mproject and mclass.visibility > private_visibility then
+		else if mclass.intro_mmodule.mpackage == mmodule.mpackage and mclass.visibility > private_visibility then
 			return "{mmodule.c_name}___{mclass.name.to_cmangle}"
 		else
 			return "{mmodule.c_name}___{mclass.c_name}"
@@ -627,7 +703,7 @@ class MClassDef
 	var in_hierarchy: nullable POSetElement[MClassDef] = null
 
 	# Is the definition the one that introduced `mclass`?
-	fun is_intro: Bool do return mclass.intro == self
+	fun is_intro: Bool do return isset mclass._intro and mclass.intro == self
 
 	# All properties introduced by the classdef
 	var intro_mproperties = new Array[MProperty]
@@ -697,6 +773,8 @@ abstract class MType
 		if sup isa MNullableType then
 			sup_accept_null = true
 			sup = sup.mtype
+		else if sup isa MNotNullType then
+			sup = sup.mtype
 		else if sup isa MNullType then
 			sup_accept_null = true
 		end
@@ -704,9 +782,13 @@ abstract class MType
 		# Can `sub` provide null or not?
 		# Thus we can match with `sup_accept_null`
 		# Also discard the nullable marker if it exists
+		var sub_reject_null = false
 		if sub isa MNullableType then
 			if not sup_accept_null then return false
 			sub = sub.mtype
+		else if sub isa MNotNullType then
+			sub_reject_null = true
+			sub = sub.mtype
 		else if sub isa MNullType then
 			return sup_accept_null
 		end
@@ -721,12 +803,16 @@ abstract class MType
 
 			assert anchor != null
 			sub = sub.lookup_bound(mmodule, anchor)
+			if sub_reject_null then sub = sub.as_notnull
 
 			#print "3.is {sub} a {sup}?"
 
 			# Manage the second layer of null/nullable
 			if sub isa MNullableType then
-				if not sup_accept_null then return false
+				if not sup_accept_null and not sub_reject_null then return false
+				sub = sub.mtype
+			else if sub isa MNotNullType then
+				sub_reject_null = true
 				sub = sub.mtype
 			else if sub isa MNullType then
 				return sup_accept_null
@@ -734,19 +820,19 @@ abstract class MType
 		end
 		#print "4.is {sub} a {sup}? <- no more resolution"
 
-		assert sub isa MClassType # It is the only remaining type
-
-		# A unfixed formal type can only accept itself
-		if sup isa MFormalType then
-			return false
+		if sub isa MBottomType then
+			return true
 		end
 
-		if sup isa MNullType then
-			# `sup` accepts only null
+		assert sub isa MClassType else print "{sub} <? {sub}" # It is the only remaining type
+
+		# Handle sup-type when the sub-type is class-based (other cases must have be identified before).
+		if sup isa MFormalType or sup isa MNullType or sup isa MBottomType then
+			# These types are not super-types of Class-based types.
 			return false
 		end
 
-		assert sup isa MClassType # It is the only remaining type
+		assert sup isa MClassType else print "got {sup} {sub.inspect}" # It is the only remaining type
 
 		# Now both are MClassType, we need to dig
 
@@ -935,7 +1021,7 @@ abstract class MType
 	# The result is returned exactly as declared in the "type" property (verbatim).
 	# So it could be another formal type.
 	#
-	# In case of conflict, the method aborts.
+	# In case of conflicts or inconsistencies in the model, the method returns a `MBottomType`.
 	fun lookup_bound(mmodule: MModule, resolved_receiver: MType): MType do return self
 
 	# Resolve the formal type to its simplest equivalent form.
@@ -949,6 +1035,8 @@ abstract class MType
 	#
 	# By default, return self.
 	# See the redefinitions for specific behavior in each kind of type.
+	#
+	# In case of conflicts or inconsistencies in the model, the method returns a `MBottomType`.
 	fun lookup_fixed(mmodule: MModule, resolved_receiver: MType): MType do return self
 
 	# Can the type be resolved?
@@ -988,16 +1076,25 @@ abstract class MType
 		return res
 	end
 
-	# Return the not nullable version of the type
-	# Is the type is already not nullable, then self is returned.
+	# Remove the base type of a decorated (proxy) type.
+	# Is the type is not decorated, then self is returned.
 	#
-	# Note: this just remove the `nullable` notation, but the result can still contains null.
+	# Most of the time it is used to return the not nullable version of a nullable type.
+	# In this case, this just remove the `nullable` notation, but the result can still contains null.
 	# For instance if `self isa MNullType` or self is a formal type bounded by a nullable type.
-	fun as_notnullable: MType
+	# If you really want to exclude the `null` value, then use `as_notnull`
+	fun undecorate: MType
 	do
 		return self
 	end
 
+	# Returns the not null version of the type.
+	# That is `self` minus the `null` value.
+	#
+	# For most types, this return `self`.
+	# For formal types, this returns a special `MNotNullType`
+	fun as_notnull: MType do return self
+
 	private var as_nullable_cache: nullable MType = null
 
 
@@ -1072,6 +1169,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
@@ -1194,10 +1293,10 @@ 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: `"standard::Map[standard::String, standard::List[standard::Int]]"`
+	# 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
@@ -1216,7 +1315,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
@@ -1265,6 +1364,8 @@ end
 # and need a context (anchor and mmodule) to be useful.
 abstract class MFormalType
 	super MType
+
+	redef var as_notnull = new MNotNullType(self) is lazy
 end
 
 # A virtual formal type.
@@ -1275,11 +1376,13 @@ 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
 	do
-		return lookup_single_definition(mmodule, resolved_receiver).bound.as(not null)
+		return lookup_single_definition(mmodule, resolved_receiver).bound or else new MBottomType(model)
 	end
 
 	private fun lookup_single_definition(mmodule: MModule, resolved_receiver: MType): MVirtualTypeDef
@@ -1310,11 +1413,12 @@ class MVirtualType
 	redef fun lookup_fixed(mmodule: MModule, resolved_receiver: MType): MType
 	do
 		assert not resolved_receiver.need_anchor
-		resolved_receiver = resolved_receiver.as_notnullable
+		resolved_receiver = resolved_receiver.undecorate
 		assert resolved_receiver isa MClassType # It is the only remaining type
 
 		var prop = lookup_single_definition(mmodule, resolved_receiver)
-		var res = prop.bound.as(not null)
+		var res = prop.bound
+		if res == null then return new MBottomType(model)
 
 		# Recursively lookup the fixed result
 		res = res.lookup_fixed(mmodule, resolved_receiver)
@@ -1404,6 +1508,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
@@ -1419,7 +1525,7 @@ class MParameterType
 	redef fun lookup_bound(mmodule: MModule, resolved_receiver: MType): MType
 	do
 		assert not resolved_receiver.need_anchor
-		resolved_receiver = resolved_receiver.as_notnullable
+		resolved_receiver = resolved_receiver.undecorate
 		assert resolved_receiver isa MClassType # It is the only remaining type
 		var goalclass = self.mclass
 		if resolved_receiver.mclass == goalclass then
@@ -1447,7 +1553,7 @@ class MParameterType
 	redef fun lookup_fixed(mmodule: MModule, resolved_receiver: MType): MType
 	do
 		assert not resolved_receiver.need_anchor
-		resolved_receiver = resolved_receiver.as_notnullable
+		resolved_receiver = resolved_receiver.undecorate
 		assert resolved_receiver isa MClassType # It is the only remaining type
 		var res = self.resolve_for(resolved_receiver.mclass.mclass_type, resolved_receiver, mmodule, false)
 		return res
@@ -1481,6 +1587,7 @@ class MParameterType
 		end
 		if resolved_receiver isa MNullableType then resolved_receiver = resolved_receiver.mtype
 		if resolved_receiver isa MParameterType then
+			assert anchor != null
 			assert resolved_receiver.mclass == anchor.mclass
 			resolved_receiver = anchor.arguments[resolved_receiver.rank]
 			if resolved_receiver isa MNullableType then resolved_receiver = resolved_receiver.mtype
@@ -1519,7 +1626,7 @@ class MParameterType
 	end
 end
 
-# A type that decorate an other type.
+# A type that decorates another type.
 #
 # The point of this class is to provide a common implementation of sevices that just forward to the original type.
 # Specific decorator are expected to redefine (or to extend) the default implementation as this suit them.
@@ -1528,10 +1635,13 @@ 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
-	redef fun as_notnullable do return mtype.as_notnullable
+	redef fun as_notnull do return mtype.as_notnull
+	redef fun undecorate do return mtype.undecorate
 	redef fun resolve_for(mtype, anchor, mmodule, cleanup_virtual)
 	do
 		var res = self.mtype.resolve_for(mtype, anchor, mmodule, cleanup_virtual)
@@ -1581,7 +1691,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}"
 
@@ -1603,16 +1713,70 @@ class MNullableType
 	end
 end
 
+# A non-null version of a formal type.
+#
+# When a formal type in bounded to a nullable type, this is the type of the not null version of it.
+class MNotNullType
+	super MProxyType
+
+	redef fun to_s do return "not null {mtype}"
+	redef var full_name is lazy do return "not null {mtype.full_name}"
+	redef var c_name is lazy do return "notnull__{mtype.c_name}"
+
+	redef fun as_notnull do return self
+
+	redef fun resolve_for(mtype, anchor, mmodule, cleanup_virtual)
+	do
+		var res = super
+		return res.as_notnull
+	end
+
+	# Efficiently returns `mtype.lookup_fixed(mmodule, resolved_receiver).as_notnull`
+	redef fun lookup_fixed(mmodule, resolved_receiver)
+	do
+		var t = super
+		if t == mtype then return self
+		return t.as_notnull
+	end
+end
+
 # The type of the only value null
 #
 # 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"
 	redef fun as_nullable do return self
+
+	redef var as_notnull = new MBottomType(model) is lazy
+	redef fun need_anchor do return false
+	redef fun resolve_for(mtype, anchor, mmodule, cleanup_virtual) do return self
+	redef fun can_resolve_for(mtype, anchor, mmodule) do return true
+
+	redef fun collect_mclassdefs(mmodule) do return new HashSet[MClassDef]
+
+	redef fun collect_mclasses(mmodule) do return new HashSet[MClass]
+
+	redef fun collect_mtypes(mmodule) do return new HashSet[MClassType]
+end
+
+# The special universal most specific type.
+#
+# This type is intended to be only used internally for type computation or analysis and should not be exposed to the user.
+# The bottom type can de used to denote things that are absurd, dead, or the absence of knowledge.
+#
+# Semantically it is the singleton `null.as_notnull`.
+class MBottomType
+	super MType
+	redef var model
+	redef fun to_s do return "bottom"
+	redef fun full_name do return "bottom"
+	redef fun c_name do return "bottom"
+	redef fun as_nullable do return model.null_type
+	redef fun as_notnull do return self
 	redef fun need_anchor do return false
 	redef fun resolve_for(mtype, anchor, mmodule, cleanup_virtual) do return self
 	redef fun can_resolve_for(mtype, anchor, mmodule) do return true
@@ -1631,6 +1795,15 @@ class MSignature
 	# The each parameter (in order)
 	var mparameters: Array[MParameter]
 
+	# Returns a parameter named `name`, if any.
+	fun mparameter_by_name(name: String): nullable MParameter
+	do
+		for p in mparameters do
+			if p.name == name then return p
+		end
+		return null
+	end
+
 	# The return type (null for a procedure)
 	var return_mtype: nullable MType
 
@@ -1664,19 +1837,29 @@ class MSignature
 		for i in [0..mparameters.length[ do
 			var parameter = mparameters[i]
 			if parameter.is_vararg then
-				assert vararg_rank == -1
+				if vararg_rank >= 0 then
+					# If there is more than one vararg,
+					# consider that additional arguments cannot be mapped.
+					vararg_rank = -1
+					break
+				end
 				vararg_rank = i
 			end
 		end
 		self.vararg_rank = vararg_rank
 	end
 
-	# The rank of the ellipsis (`...`) for vararg (starting from 0).
+	# The rank of the main ellipsis (`...`) for vararg (starting from 0).
 	# value is -1 if there is no vararg.
 	# Example: for "(a: Int, b: Bool..., c: Char)" #-> vararg_rank=1
+	#
+	# From a model POV, a signature can contain more than one vararg parameter,
+	# the `vararg_rank` just indicates the one that will receive the additional arguments.
+	# However, currently, if there is more that one vararg parameter, no one will be the main one,
+	# and additional arguments will be refused.
 	var vararg_rank: Int is noinit
 
-	# The number or parameters
+	# The number of parameters
 	fun arity: Int do return mparameters.length
 
 	redef fun to_s
@@ -1724,7 +1907,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
@@ -1778,14 +1961,29 @@ abstract class MProperty
 	var intro_mclassdef: MClassDef
 
 	# The (short) name of the property
-	redef var name: String
+	redef var name
+
+	redef var location
+
+	redef fun mdoc_or_fallback do return intro.mdoc_or_fallback
 
 	# 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.
-	# Example: "my_project::my_module::MyClass::my_method"
+	# 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
@@ -1835,7 +2033,7 @@ abstract class MProperty
 	fun lookup_definitions(mmodule: MModule, mtype: MType): Array[MPROPDEF]
 	do
 		assert not mtype.need_anchor
-		mtype = mtype.as_notnullable
+		mtype = mtype.undecorate
 
 		var cache = self.lookup_definitions_cache[mmodule, mtype]
 		if cache != null then return cache
@@ -1875,7 +2073,7 @@ abstract class MProperty
 	fun lookup_super_definitions(mmodule: MModule, mtype: MType): Array[MPROPDEF]
 	do
 		assert not mtype.need_anchor
-		mtype = mtype.as_notnullable
+		mtype = mtype.undecorate
 
 		# First, select all candidates
 		var candidates = new Array[MPROPDEF]
@@ -1953,7 +2151,7 @@ abstract class MProperty
 	# REQUIRE: `mtype.has_mproperty(mmodule, self)`
 	fun lookup_all_definitions(mmodule: MModule, mtype: MType): Array[MPROPDEF]
 	do
-		mtype = mtype.as_notnullable
+		mtype = mtype.undecorate
 
 		var cache = self.lookup_all_definitions_cache[mmodule, mtype]
 		if cache != null then return cache
@@ -2015,6 +2213,10 @@ class MMethod
 	do
 		return self.is_init
 	end
+
+	# A specific method that is safe to call on null.
+	# Currently, only `==`, `!=` and `is_same_instance` are safe
+	fun is_null_safe: Bool do return name == "==" or name == "!=" or name == "is_same_instance"
 end
 
 # A global attribute
@@ -2055,8 +2257,7 @@ abstract class MPropDef
 	# The associated global property
 	var mproperty: MPROPERTY
 
-	# The origin of the definition
-	var location: Location
+	redef var location: Location
 
 	init
 	do
@@ -2066,7 +2267,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`
@@ -2080,31 +2281,31 @@ 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
 			res.append name
 		else
 			# Just try to simplify each part
-			if mclassdef.mmodule.mproject != mproperty.intro_mclassdef.mmodule.mproject then
+			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 project ("p"=="q"), but private visibility,
+				# 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.mproject then
+				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 "::"
@@ -2144,11 +2345,11 @@ 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 mproperty.intro == self
+	fun is_intro: Bool do return isset mproperty._intro and mproperty.intro == self
 
 	# Return the next definition in linearization of `mtype`.
 	#
@@ -2248,7 +2449,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