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

diff --git a/src/model/model.nit b/src/model/model.nit
index 6c8798b..030cca9 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]
@@ -66,7 +75,7 @@ redef class Model
 	# Collections of classes grouped by their short name
 	private var mclasses_by_name = new MultiHashMap[String, MClass]
 
-	# Return all class named `name`.
+	# Return all classes named `name`.
 	#
 	# If such a class does not exist, null is returned
 	# (instead of an empty array)
@@ -150,7 +159,7 @@ redef class MModule
 		return self.in_importation <= mclass.intro_mmodule
 	end
 
-	# Full hierarchy of introduced ans imported classes.
+	# Full hierarchy of introduced and imported classes.
 	#
 	# Create a new hierarchy got by flattening the classes for the module
 	# and its imported modules.
@@ -243,8 +252,8 @@ redef class MModule
 	# The primitive type `String`
 	var string_type: MClassType = self.get_primitive_class("String").mclass_type is lazy
 
-	# The primitive type `NativeString`
-	var native_string_type: MClassType = self.get_primitive_class("NativeString").mclass_type is lazy
+	# The primitive type `CString`
+	var native_string_type: MClassType = self.get_primitive_class("CString").mclass_type is lazy
 
 	# A primitive type of `Array`
 	fun array_type(elt_type: MType): MClassType do return array_class.get_mtype([elt_type])
@@ -285,20 +294,21 @@ 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
 			end
-			print("Fatal Error: no primitive class {name} in {self}")
+			print_error("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} in {self}:"
 			for c in cla do msg += " {c.full_name}"
-			print msg
+			print_error msg
 			#exit(1)
 		end
 		return cla.first
@@ -317,7 +327,7 @@ redef class MModule
 			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}")
+				print_error("Fatal Error: ambigous property name '{name}'; conflict between {mprop.full_name} and {res.full_name}")
 				abort
 			end
 		end
@@ -378,14 +388,17 @@ class MClass
 	super MEntity
 
 	# The module that introduce the class
+	#
 	# While classes are not bound to a specific module,
-	# the introducing module is used for naming an visibility
+	# the introducing module is used for naming and visibility.
 	var intro_mmodule: MModule
 
 	# The short name of the class
 	# In Nit, the name of a class cannot evolve in refinements
 	redef var name
 
+	redef var location
+
 	# The canonical name of the class
 	#
 	# It is the name of the class prefixed by the full_name of the `intro_mmodule`
@@ -462,7 +475,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
@@ -506,12 +519,12 @@ class MClass
 
 	# The principal static type of the class.
 	#
-	# For non-generic class, mclass_type is the only `MClassType` based
+	# For non-generic class, `mclass_type` is the only `MClassType` based
 	# on self.
 	#
 	# For a generic class, the arguments are the formal parameters.
-	# i.e.: for the class Array[E:Object], the `mclass_type` is Array[E].
-	# If you want Array[Object] the see `MClassDef::bound_mtype`
+	# i.e.: for the class `Array[E:Object]`, the `mclass_type` is `Array[E]`.
+	# If you want `Array[Object]`, see `MClassDef::bound_mtype`.
 	#
 	# For generic classes, the mclass_type is also the way to get a formal
 	# generic parameter type.
@@ -552,6 +565,8 @@ class MClass
 
 	# 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
 
 
@@ -588,8 +603,9 @@ class MClassDef
 	# ENSURE: `bound_mtype.mclass == self.mclass`
 	var bound_mtype: MClassType
 
-	# The origin of the definition
-	var location: Location
+	redef var location
+
+	redef fun visibility do return mclass.visibility
 
 	# Internal name combining the module and the class
 	# Example: "mymodule$MyClass"
@@ -704,8 +720,11 @@ class MClassDef
 	# All properties introduced by the classdef
 	var intro_mproperties = new Array[MProperty]
 
-	# All property definitions in the class (introductions and redefinitions)
+	# All property introductions and redefinitions in `self` (not inheritance).
 	var mpropdefs = new Array[MPropDef]
+
+	# All property introductions and redefinitions (not inheritance) in `self` by its associated property.
+	var mpropdefs_by_property = new HashMap[MProperty, MPropDef]
 end
 
 # A global static type
@@ -816,19 +835,19 @@ abstract class MType
 		end
 		#print "4.is {sub} a {sup}? <- no more resolution"
 
-		if sub isa MBottomType then
+		if sub isa MBottomType or sub isa MErrorType then
 			return true
 		end
 
-		assert sub isa MClassType else print "{sub} <? {sub}" # It is the only remaining type
+		assert sub isa MClassType else print_error "{sub} <? {sup}" # 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
+		if sup isa MFormalType or sup isa MNullType or sup isa MBottomType or sup isa MErrorType then
 			# These types are not super-types of Class-based types.
 			return false
 		end
 
-		assert sup isa MClassType else print "got {sup} {sub.inspect}" # It is the only remaining type
+		assert sup isa MClassType else print_error "got {sup} {sub.inspect}" # It is the only remaining type
 
 		# Now both are MClassType, we need to dig
 
@@ -1017,7 +1036,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 conflicts or inconsistencies in the model, the method returns a `MBottomType`.
+	# In case of conflicts or inconsistencies in the model, the method returns a `MErrorType`.
 	fun lookup_bound(mmodule: MModule, resolved_receiver: MType): MType do return self
 
 	# Resolve the formal type to its simplest equivalent form.
@@ -1032,9 +1051,24 @@ 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`.
+	# In case of conflicts or inconsistencies in the model, the method returns a `MErrorType`.
 	fun lookup_fixed(mmodule: MModule, resolved_receiver: MType): MType do return self
 
+	# Is the type a `MErrorType` or contains an `MErrorType`?
+	#
+	# `MErrorType` are used in result with conflict or inconsistencies.
+	#
+	# See `is_legal_in` to check conformity with generic bounds.
+	fun is_ok: Bool do return true
+
+	# Is the type legal in a given `mmodule` (with an optional `anchor`)?
+	#
+	# A type is valid if:
+	#
+	# * it does not contain a `MErrorType` (see `is_ok`).
+	# * its generic formal arguments are within their bounds.
+	fun is_legal_in(mmodule: MModule, anchor: nullable MClassType): Bool do return is_ok
+
 	# Can the type be resolved?
 	#
 	# In order to resolve open types, the formal types must make sence.
@@ -1165,6 +1199,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
@@ -1331,6 +1367,24 @@ class MGenericType
 		return true
 	end
 
+	redef fun is_ok
+	do
+		for t in arguments do if not t.is_ok then return false
+		return super
+	end
+
+	redef fun is_legal_in(mmodule, anchor)
+	do
+		var mtype
+		if need_anchor then
+			assert anchor != null
+			mtype = anchor_to(mmodule, anchor)
+		else
+			mtype = self
+		end
+		if not mtype.is_ok then return false
+		return mtype.is_subtype(mmodule, null, mtype.mclass.intro.bound_mtype)
+	end
 
 	redef fun depth
 	do
@@ -1370,11 +1424,15 @@ 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
+	redef fun lookup_bound(mmodule, resolved_receiver)
 	do
-		return lookup_single_definition(mmodule, resolved_receiver).bound or else new MBottomType(model)
+		# There is two possible invalid cases: the vt does not exists in resolved_receiver or the bound is broken
+		if not resolved_receiver.has_mproperty(mmodule, mproperty) then return new MErrorType(model)
+		return lookup_single_definition(mmodule, resolved_receiver).bound or else new MErrorType(model)
 	end
 
 	private fun lookup_single_definition(mmodule: MModule, resolved_receiver: MType): MVirtualTypeDef
@@ -1410,7 +1468,7 @@ class MVirtualType
 
 		var prop = lookup_single_definition(mmodule, resolved_receiver)
 		var res = prop.bound
-		if res == null then return new MBottomType(model)
+		if res == null then return new MErrorType(model)
 
 		# Recursively lookup the fixed result
 		res = res.lookup_fixed(mmodule, resolved_receiver)
@@ -1431,6 +1489,9 @@ class MVirtualType
 	do
 		if not cleanup_virtual then return self
 		assert can_resolve_for(mtype, anchor, mmodule)
+
+		if mproperty.is_selftype then return mtype
+
 		# self is a virtual type declared (or inherited) in mtype
 		# The point of the function it to get the bound of the virtual type that make sense for mtype
 		# But because mtype is maybe a virtual/formal type, we need to get a real receiver first
@@ -1500,6 +1561,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
@@ -1530,7 +1593,8 @@ class MParameterType
 				return res
 			end
 		end
-		abort
+		# Cannot found `self` in `resolved_receiver`
+		return new MErrorType(model)
 	end
 
 	# A PT is fixed when:
@@ -1625,6 +1689,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
@@ -1641,6 +1707,10 @@ abstract class MProxyType
 		return self.mtype.can_resolve_for(mtype, anchor, mmodule)
 	end
 
+	redef fun is_ok do return mtype.is_ok
+
+	redef fun is_legal_in(mmodule, anchor) do return mtype.is_legal_in(mmodule, anchor)
+
 	redef fun lookup_fixed(mmodule, resolved_receiver)
 	do
 		var t = mtype.lookup_fixed(mmodule, resolved_receiver)
@@ -1754,9 +1824,10 @@ 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.
+# The bottom type can de used to denote things that are dead (no instance).
 #
 # Semantically it is the singleton `null.as_notnull`.
+# Is also means that `self.as_nullable == null`.
 class MBottomType
 	super MType
 	redef var model
@@ -1776,6 +1847,31 @@ class MBottomType
 	redef fun collect_mtypes(mmodule) do return new HashSet[MClassType]
 end
 
+# A special type used as a silent error marker when building types.
+#
+# This type is intended to be only used internally for type operation and should not be exposed to the user.
+# The error type can de used to denote things that are conflicting or inconsistent.
+#
+# Some methods on types can return a `MErrorType` to denote a broken or a conflicting result.
+# Use `is_ok` to check if a type is (or contains) a `MErrorType` .
+class MErrorType
+	super MType
+	redef var model
+	redef fun to_s do return "error"
+	redef fun full_name do return "error"
+	redef fun c_name do return "error"
+	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 is_ok do return false
+
+	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
+
 # A signature of a method
 class MSignature
 	super MType
@@ -1951,6 +2047,10 @@ abstract class MProperty
 	# The (short) name of the property
 	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 currently the short-`name` prefixed by the short-name of the class and the full-name of the module.
@@ -1976,7 +2076,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
@@ -2025,14 +2125,27 @@ abstract class MProperty
 		#print "select prop {mproperty} for {mtype} in {self}"
 		# First, select all candidates
 		var candidates = new Array[MPROPDEF]
-		for mpropdef in self.mpropdefs do
-			# If the definition is not imported by the module, then skip
-			if not mmodule.in_importation <= mpropdef.mclassdef.mmodule then continue
-			# If the definition is not inherited by the type, then skip
-			if not mtype.is_subtype(mmodule, null, mpropdef.mclassdef.bound_mtype) then continue
-			# Else, we keep it
-			candidates.add(mpropdef)
+
+		# Here we have two strategies: iterate propdefs or iterate classdefs.
+		var mpropdefs = self.mpropdefs
+		if mpropdefs.length <= 1 or mpropdefs.length < mtype.collect_mclassdefs(mmodule).length then
+			# Iterate on all definitions of `self`, keep only those inherited by `mtype` in `mmodule`
+			for mpropdef in mpropdefs do
+				# If the definition is not imported by the module, then skip
+				if not mmodule.in_importation <= mpropdef.mclassdef.mmodule then continue
+				# If the definition is not inherited by the type, then skip
+				if not mtype.is_subtype(mmodule, null, mpropdef.mclassdef.bound_mtype) then continue
+				# Else, we keep it
+				candidates.add(mpropdef)
+			end
+		else
+			# Iterate on all super-classdefs of `mtype`, keep only the definitions of `self`, if any.
+			for mclassdef in mtype.collect_mclassdefs(mmodule) do
+				var p = mclassdef.mpropdefs_by_property.get_or_null(self)
+				if p != null then candidates.add p
+			end
 		end
+
 		# Fast track for only one candidate
 		if candidates.length <= 1 then
 			self.lookup_definitions_cache[mmodule, mtype] = candidates
@@ -2108,7 +2221,7 @@ abstract class MProperty
 			end
 		end
 		if res.is_empty then
-			print "All lost! {candidates.join(", ")}"
+			print_error "All lost! {candidates.join(", ")}"
 			# FIXME: should be abort!
 		end
 		return res
@@ -2219,6 +2332,9 @@ class MVirtualTypeProp
 
 	# The formal type associated to the virtual type property
 	var mvirtualtype = new MVirtualType(self)
+
+	# Is `self` the special virtual type `SELF`?
+	var is_selftype: Bool is lazy do return name == "SELF"
 end
 
 # A definition of a property (local property)
@@ -2241,13 +2357,15 @@ 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
 		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