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

diff --git a/src/modelize/modelize_property.nit b/src/modelize/modelize_property.nit
index a5b3228..d8fd96d 100644
--- a/src/modelize/modelize_property.nit
+++ b/src/modelize/modelize_property.nit
@@ -17,10 +17,11 @@
 # Analysis and verification of property definitions to instantiate model element
 module modelize_property
 
-import modelize_class
+intrude import modelize_class
 private import annotation
 
 redef class ToolContext
+	# Run `AClassdef::build_property` on the classdefs of each module
 	var modelize_property_phase: Phase = new ModelizePropertyPhase(self, [modelize_class_phase])
 end
 
@@ -36,9 +37,47 @@ private class ModelizePropertyPhase
 end
 
 redef class ModelBuilder
-	# Register the npropdef associated to each mpropdef
-	# FIXME: why not refine the `MPropDef` class with a nullable attribute?
-	var mpropdef2npropdef = new HashMap[MPropDef, APropdef]
+	# Registration of the npropdef associated to each mpropdef.
+	#
+	# Public clients need to use `mpropdef2node` to access stuff.
+	private var mpropdef2npropdef = new HashMap[MPropDef, APropdef]
+
+	# Retrieve the associated AST node of a mpropertydef.
+	# This method is used to associate model entity with syntactic entities.
+	#
+	# If the property definition is not associated with a node, returns `null`.
+	fun mpropdef2node(mpropdef: MPropDef): nullable ANode
+	do
+		var res
+		res = mpropdef2npropdef.get_or_null(mpropdef)
+		if res != null then
+			# Run the phases on it
+			toolcontext.run_phases_on_npropdef(res)
+			return res
+		end
+		if mpropdef isa MMethodDef and mpropdef.mproperty.is_root_init then
+			res = mclassdef2nclassdef.get_or_null(mpropdef.mclassdef)
+			if res != null then return res
+		end
+		return null
+	end
+
+	# Retrieve all the attributes nodes localy definied
+	# FIXME think more about this method and how the separations separate/global and ast/model should be done.
+	fun collect_attr_propdef(mclassdef: MClassDef): Array[AAttrPropdef]
+	do
+		var res = new Array[AAttrPropdef]
+		var n = mclassdef2nclassdef.get_or_null(mclassdef)
+		if n == null then return res
+		for npropdef in n.n_propdefs do
+			if npropdef isa AAttrPropdef then
+				# Run the phases on it
+				toolcontext.run_phases_on_npropdef(npropdef)
+				res.add(npropdef)
+			end
+		end
+		return res
+	end
 
 	# Build the properties of `nclassdef`.
 	# REQUIRE: all superclasses are built.
@@ -54,6 +93,7 @@ redef class ModelBuilder
 			build_properties(mclassdef2nclassdef[superclassdef])
 		end
 
+		mclassdef.build_self_type(self, nclassdef)
 		for nclassdef2 in nclassdef.all_defs do
 			for npropdef in nclassdef2.n_propdefs do
 				npropdef.build_property(self, mclassdef)
@@ -174,7 +214,8 @@ redef class ModelBuilder
 		# Look for most-specific new-stype init definitions
 		var spropdefs = the_root_init_mmethod.lookup_super_definitions(mclassdef.mmodule, mclassdef.bound_mtype)
 		if spropdefs.is_empty then
-			toolcontext.fatal_error(nclassdef.location, "Fatal error: {mclassdef} does not specialize {the_root_init_mmethod.intro_mclassdef}. Possible duplication of the root class `Object`?")
+			toolcontext.error(nclassdef.location, "Error: {mclassdef} does not specialize {the_root_init_mmethod.intro_mclassdef}. Possible duplication of the root class `Object`?")
+			return
 		end
 
 		# Search the longest-one and checks for conflict
@@ -291,7 +332,8 @@ redef class MPropDef
 end
 
 redef class AClassdef
-	var build_properties_is_done = false
+	# Marker used in `ModelBuilder::build_properties`
+	private var build_properties_is_done = false
 
 	# The free init (implicitely constructed by the class if required)
 	var mfree_init: nullable MMethodDef = null
@@ -310,6 +352,50 @@ redef class MClassDef
 	# What is the `APropdef` associated to a `MProperty`?
 	# Used to check multiple definition of a property.
 	var mprop2npropdef: Map[MProperty, APropdef] = new HashMap[MProperty, APropdef]
+
+	# Build the virtual type `SELF` only for introduction `MClassDef`
+	fun build_self_type(modelbuilder: ModelBuilder, nclassdef: AClassdef)
+	do
+		if not is_intro then return
+
+		var name = "SELF"
+		var mprop = modelbuilder.try_get_mproperty_by_name(nclassdef, self, name)
+
+		# If SELF type is declared nowherer?
+		if mprop == null then return
+
+		# SELF is not a virtual type? it is weird but we ignore it
+		if not mprop isa MVirtualTypeProp then return
+
+		# Is this the intro of SELF in the library?
+		var intro = mprop.intro
+		var intro_mclassdef = intro.mclassdef
+		if intro_mclassdef == self then
+			var nintro = modelbuilder.mpropdef2npropdef[intro]
+
+			# SELF must be declared in Object, otherwise this will create conflicts
+			if intro_mclassdef.mclass.name != "Object" then
+				modelbuilder.error(nintro, "Error: the virtual type SELF must be declared in Object.")
+			end
+
+			# SELF must be public
+			if mprop.visibility != public_visibility then
+				modelbuilder.error(nintro, "Error: the virtual type SELF must be public.")
+			end
+
+			# SELF must not be fixed
+			if intro.is_fixed then
+				modelbuilder.error(nintro, "Error: the virtual type SELF cannot be fixed.")
+			end
+
+			return
+		end
+
+		# This class introduction inherits a SELF
+		# We insert an artificial property to update it
+		var mpropdef = new MVirtualTypeDef(self, mprop, self.location)
+		mpropdef.bound = mclass.mclass_type
+	end
 end
 
 redef class APropdef
@@ -393,11 +479,24 @@ redef class APropdef
 			return false
 
 		end
+		if mprop isa MMethod and mprop.is_root_init then return true
 		if kwredef == null then
 			if need_redef then
 				modelbuilder.error(self, "Redef error: {mclassdef.mclass}::{mprop.name} is an inherited property. To redefine it, add the redef keyword.")
 				return false
 			end
+
+			# Check for full-name conflicts in the project.
+			# A public property should have a unique qualified name `project::class::prop`.
+			if mprop.intro_mclassdef.mmodule.mgroup != null and mprop.visibility >= protected_visibility then
+				var others = modelbuilder.model.get_mproperties_by_name(mprop.name)
+				if others != null then for other in others do
+					if other != mprop and other.intro_mclassdef.mmodule.mgroup != null and other.intro_mclassdef.mmodule.mgroup.mproject == mprop.intro_mclassdef.mmodule.mgroup.mproject and other.intro_mclassdef.mclass.name == mprop.intro_mclassdef.mclass.name and other.visibility >= protected_visibility then
+						modelbuilder.advice(self, "full-name-conflict", "Warning: A property named `{other.full_name}` is already defined in module `{other.intro_mclassdef.mmodule}` for the class `{other.intro_mclassdef.mclass.name}`.")
+						break
+					end
+				end
+			end
 		else
 			if not need_redef then
 				modelbuilder.error(self, "Error: No property {mclassdef.mclass}::{mprop.name} is inherited. Remove the redef keyword to define a new property.")
@@ -490,16 +589,12 @@ redef class AMethPropdef
 
 
 	# Can self be used as a root init?
-	private fun look_like_a_root_init(modelbuilder: ModelBuilder): Bool
+	private fun look_like_a_root_init(modelbuilder: ModelBuilder, mclassdef: MClassDef): Bool
 	do
 		# Need the `init` keyword
 		if n_kwinit == null then return false
 		# Need to by anonymous
 		if self.n_methid != null then return false
-		# No parameters
-		if self.n_signature.n_params.length > 0 then return false
-		# Cannot be private or something
-		if not self.n_visibility isa APublicVisibility then return false
 		# No annotation on itself
 		if get_single_annotation("old_style_init", modelbuilder) != null then return false
 		# Nor on its module
@@ -509,6 +604,16 @@ redef class AMethPropdef
 			var old = amoddecl.get_single_annotation("old_style_init", modelbuilder)
 			if old != null then return false
 		end
+		# No parameters
+		if self.n_signature.n_params.length > 0 then
+			modelbuilder.advice(self, "old-init", "Warning: init with signature in {mclassdef}")
+			return false
+		end
+		# Cannot be private or something
+		if not self.n_visibility isa APublicVisibility then
+			modelbuilder.advice(self, "old-init", "Warning: non-public init in {mclassdef}")
+			return false
+		end
 
 		return true
 	end
@@ -547,9 +652,10 @@ redef class AMethPropdef
 			end
 		end
 
+		var look_like_a_root_init = look_like_a_root_init(modelbuilder, mclassdef)
 		var mprop: nullable MMethod = null
 		if not is_init or n_kwredef != null then mprop = modelbuilder.try_get_mproperty_by_name(name_node, mclassdef, name).as(nullable MMethod)
-		if mprop == null and look_like_a_root_init(modelbuilder) then
+		if mprop == null and look_like_a_root_init then
 			mprop = modelbuilder.the_root_init_mmethod
 			var nb = n_block
 			if nb isa ABlockExpr and nb.n_expr.is_empty and n_doc == null then
@@ -559,18 +665,29 @@ redef class AMethPropdef
 		if mprop == null then
 			var mvisibility = new_property_visibility(modelbuilder, mclassdef, self.n_visibility)
 			mprop = new MMethod(mclassdef, name, mvisibility)
-			if look_like_a_root_init(modelbuilder) and modelbuilder.the_root_init_mmethod == null then
+			if look_like_a_root_init and modelbuilder.the_root_init_mmethod == null then
 				modelbuilder.the_root_init_mmethod = mprop
 				mprop.is_root_init = true
 			end
 			mprop.is_init = is_init
 			mprop.is_new = n_kwnew != null
 			if parent isa ATopClassdef then mprop.is_toplevel = true
-			if not self.check_redef_keyword(modelbuilder, mclassdef, n_kwredef, false, mprop) then return
+			self.check_redef_keyword(modelbuilder, mclassdef, n_kwredef, false, mprop)
 		else
-			if not mprop.is_root_init and not self.check_redef_keyword(modelbuilder, mclassdef, n_kwredef, not self isa AMainMethPropdef, mprop) then return
+			if not self.check_redef_keyword(modelbuilder, mclassdef, n_kwredef, not self isa AMainMethPropdef, mprop) then return
 			check_redef_property_visibility(modelbuilder, self.n_visibility, mprop)
 		end
+
+		# Check name conflicts in the local class for constructors.
+		if is_init then
+			for p, n in mclassdef.mprop2npropdef do
+				if p != mprop and p isa MMethod and p.name == name then
+					check_redef_keyword(modelbuilder, mclassdef, n_kwredef, false, p)
+					break
+				end
+			end
+		end
+
 		mclassdef.mprop2npropdef[mprop] = self
 
 		var mpropdef = new MMethodDef(mclassdef, mprop, self.location)
@@ -580,9 +697,9 @@ redef class AMethPropdef
 		self.mpropdef = mpropdef
 		modelbuilder.mpropdef2npropdef[mpropdef] = self
 		if mpropdef.is_intro then
-			modelbuilder.toolcontext.info("{mpropdef} introduces new method {mprop.full_name}", 3)
+			modelbuilder.toolcontext.info("{mpropdef} introduces new method {mprop.full_name}", 4)
 		else
-			modelbuilder.toolcontext.info("{mpropdef} redefines method {mprop.full_name}", 3)
+			modelbuilder.toolcontext.info("{mpropdef} redefines method {mprop.full_name}", 4)
 		end
 	end
 
@@ -624,6 +741,9 @@ redef class AMethPropdef
 			msignature = mpropdef.mproperty.intro.msignature
 			if msignature == null then return # Skip error
 
+			# The local signature is adapted to use the local formal types, if any.
+			msignature = msignature.resolve_for(mclassdef.mclass.mclass_type, mclassdef.bound_mtype, mmodule, false)
+
 			# Check inherited signature arity
 			if param_names.length != msignature.arity then
 				var node: ANode
@@ -893,11 +1013,17 @@ redef class AAttrPropdef
 			if mtype == null then return
 		end
 
+		var inherited_type: nullable MType = null
 		# Inherit the type from the getter (usually an abstract getter)
-		if mtype == null and mreadpropdef != null and not mreadpropdef.is_intro then
+		if mreadpropdef != null and not mreadpropdef.is_intro then
 			var msignature = mreadpropdef.mproperty.intro.msignature
 			if msignature == null then return # Error, thus skipped
-			mtype = msignature.return_mtype
+			inherited_type = msignature.return_mtype
+			if inherited_type != null then
+				# The inherited type is adapted to use the local formal types, if any.
+				inherited_type = inherited_type.resolve_for(mclassdef.mclass.mclass_type, mclassdef.bound_mtype, mmodule, false)
+				if mtype == null then mtype = inherited_type
+			end
 		end
 
 		var nexpr = self.n_expr
@@ -929,7 +1055,7 @@ redef class AAttrPropdef
 
 				if mtype == null then return
 			end
-		else if ntype != null then
+		else if ntype != null and inherited_type == mtype then
 			if nexpr isa ANewExpr then
 				var xmtype = modelbuilder.resolve_mtype(mmodule, mclassdef, nexpr.n_type)
 				if xmtype == mtype then
@@ -1083,6 +1209,11 @@ redef class ATypePropdef
 		var mpropdef = new MVirtualTypeDef(mclassdef, mprop, self.location)
 		self.mpropdef = mpropdef
 		modelbuilder.mpropdef2npropdef[mpropdef] = self
+		if mpropdef.is_intro then
+			modelbuilder.toolcontext.info("{mpropdef} introduces new type {mprop.full_name}", 4)
+		else
+			modelbuilder.toolcontext.info("{mpropdef} redefines type {mprop.full_name}", 4)
+		end
 		set_doc(mpropdef, modelbuilder)
 
 		var atfixed = get_single_annotation("fixed", modelbuilder)
@@ -1141,7 +1272,8 @@ redef class ATypePropdef
 		# Check redefinitions
 		bound = mpropdef.bound.as(not null)
 		for p in mpropdef.mproperty.lookup_super_definitions(mmodule, anchor) do
-			var supbound = p.bound.as(not null)
+			var supbound = p.bound
+			if supbound == null then break # broken super bound, skip error
 			if p.is_fixed then
 				modelbuilder.error(self, "Redef Error: Virtual type {mpropdef.mproperty} is fixed in super-class {p.mclassdef.mclass}")
 				break