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

diff --git a/src/modelize_property.nit b/src/modelize_property.nit
index c5847f6..57e847b 100644
--- a/src/modelize_property.nit
+++ b/src/modelize_property.nit
@@ -18,6 +18,7 @@
 module modelize_property
 
 import modelize_class
+private import annotation
 
 redef class ToolContext
 	var modelize_property_phase: Phase = new ModelizePropertyPhase(self, [modelize_class_phase])
@@ -28,6 +29,7 @@ private class ModelizePropertyPhase
 	redef fun process_nmodule(nmodule)
 	do
 		for nclassdef in nmodule.n_classdefs do
+			if nclassdef.all_defs == null then continue # skip non principal classdef
 			toolcontext.modelbuilder.build_properties(nclassdef)
 		end
 	end
@@ -48,21 +50,29 @@ redef class ModelBuilder
 		var mclassdef = nclassdef.mclassdef.as(not null)
 		if mclassdef.in_hierarchy == null then return # Skip error
 		for superclassdef in mclassdef.in_hierarchy.direct_greaters do
+			if not mclassdef2nclassdef.has_key(superclassdef) then continue
 			build_properties(mclassdef2nclassdef[superclassdef])
 		end
 
-		for npropdef in nclassdef.n_propdefs do
-			npropdef.build_property(self, nclassdef)
-		end
-		for npropdef in nclassdef.n_propdefs do
-			npropdef.build_signature(self, nclassdef)
-		end
-		for npropdef in nclassdef.n_propdefs do
-			npropdef.check_signature(self, nclassdef)
+		for nclassdef2 in nclassdef.all_defs do
+			for npropdef in nclassdef2.n_propdefs do
+				npropdef.build_property(self, mclassdef)
+			end
+			for npropdef in nclassdef2.n_propdefs do
+				npropdef.build_signature(self)
+			end
+			for npropdef in nclassdef2.n_propdefs do
+				npropdef.check_signature(self)
+			end
 		end
 		process_default_constructors(nclassdef)
 	end
 
+	# the root init of the Object class
+	# Is usually implicitly defined
+	# Then explicit or implicit definitions of root-init are attached to it
+	var the_root_init_mmethod: nullable MMethod
+
 	# Introduce or inherit default constructor
 	# This is the last part of `build_properties`.
 	private fun process_default_constructors(nclassdef: AClassdef)
@@ -72,29 +82,60 @@ redef class ModelBuilder
 		# Are we a refinement
 		if not mclassdef.is_intro then return
 
+		var mmodule = nclassdef.mclassdef.mmodule
+
+		# Look for the init in Object, or create it
+		if mclassdef.mclass.name == "Object" and the_root_init_mmethod == null then
+			# Create the implicit root-init method
+			var mprop = new MMethod(mclassdef, "init", mclassdef.mclass.visibility)
+			mprop.is_root_init = true
+			var mpropdef = new MMethodDef(mclassdef, mprop, nclassdef.location)
+			var mparameters = new Array[MParameter]
+			var msignature = new MSignature(mparameters, null)
+			mpropdef.msignature = msignature
+			mpropdef.new_msignature = msignature
+			mprop.is_init = true
+			nclassdef.mfree_init = mpropdef
+			self.toolcontext.info("{mclassdef} gets a free empty constructor {mpropdef}{msignature}", 3)
+			the_root_init_mmethod = mprop
+			return
+		end
+
 		# Is the class forbid constructors?
 		if not mclassdef.mclass.kind.need_init then return
 
 		# Is there already a constructor defined?
+		var defined_init: nullable MMethodDef = null
 		for mpropdef in mclassdef.mpropdefs do
 			if not mpropdef isa MMethodDef then continue
-			if mpropdef.mproperty.is_init then return
+			if not mpropdef.mproperty.is_init then continue
+			if mpropdef.mproperty.is_root_init then
+				assert defined_init == null
+				defined_init = mpropdef
+			else
+				# An explicit old-style init, so return
+				return
+			end
 		end
 
 		if not nclassdef isa AStdClassdef then return
 
-		var mmodule = nclassdef.mclassdef.mmodule
-		# Do we inherit for a constructor?
-		var combine = new Array[MMethod]
-		var inhc: nullable MClass = null
-		for st in mclassdef.supertypes do
+		# Do we inherit a old-style constructor?
+		var combine = new Array[MMethod] # old-style constructors without arguments
+		var inhc: nullable MClass = null # single super-class with a constructor with arguments
+		if defined_init == null then for st in mclassdef.supertypes do
 			var c = st.mclass
 			if not c.kind.need_init then continue
-			st = st.anchor_to(mmodule, nclassdef.mclassdef.bound_mtype)
+			st = st.anchor_to(mmodule, mclassdef.bound_mtype)
 			var candidate = self.try_get_mproperty_by_name2(nclassdef, mmodule, st, "init").as(nullable MMethod)
-			if candidate != null and candidate.intro.msignature.arity == 0 then
-				combine.add(candidate)
-				continue
+			if candidate != null then
+				if candidate.is_root_init then continue
+				if candidate.intro.msignature != null then
+					if candidate.intro.msignature.arity == 0 then
+						combine.add(candidate)
+						continue
+					end
+				end
 			end
 			var inhc2 = c.inherit_init_from
 			if inhc2 == null then inhc2 = c
@@ -108,38 +149,132 @@ redef class ModelBuilder
 
 		# Collect undefined attributes
 		var mparameters = new Array[MParameter]
+		var initializers = new Array[MProperty]
+		var anode: nullable ANode = null
 		for npropdef in nclassdef.n_propdefs do
-			if npropdef isa AAttrPropdef and npropdef.n_expr == null then
+			if npropdef isa AAttrPropdef then
 				if npropdef.mpropdef == null then return # Skip broken attribute
+				var at = npropdef.get_single_annotation("noinit", self)
+				if at != null then
+					npropdef.noinit = true
+					if npropdef.n_expr != null then
+						self.error(at, "Error: `noinit` attributes cannot have an initial value")
+					end
+					continue # Skip noinit attributes
+				end
+				if npropdef.n_expr != null then continue
 				var paramname = npropdef.mpropdef.mproperty.name.substring_from(1)
 				var ret_type = npropdef.mpropdef.static_mtype
 				if ret_type == null then return
 				var mparameter = new MParameter(paramname, ret_type, false)
 				mparameters.add(mparameter)
+				var msetter = npropdef.mwritepropdef
+				if msetter == null then
+					# No setter, it is a old-style attribute, so just add it
+					initializers.add(npropdef.mpropdef.mproperty)
+				else
+					# Add the setter to the list
+					initializers.add(msetter.mproperty)
+				end
+				if anode == null then anode = npropdef
 			end
 		end
+		if anode == null then anode = nclassdef
 
 		if combine.is_empty and inhc != null then
+			if not mparameters.is_empty then
+				self.error(anode,"Error: {mclassdef} cannot inherit constructors from {inhc} because there is attributes without initial values: {mparameters.join(", ")}")
+				return
+			end
+
 			# TODO: actively inherit the consturctor
 			self.toolcontext.info("{mclassdef} inherits all constructors from {inhc}", 3)
-			mclassdef.mclass.inherit_init_from = inhc
-			return
+			#mclassdef.mclass.inherit_init_from = inhc
+			#return
 		end
 
 		if not combine.is_empty and inhc != null then
 			self.error(nclassdef, "Error: Cannot provide a defaut constructor: conflict for {combine.join(", ")} and {inhc}")
 			return
 		end
-
 		if not combine.is_empty then
+			if mparameters.is_empty and combine.length == 1 then
+				# No need to create a local init, the inherited one is enough
+				inhc = combine.first.intro_mclassdef.mclass
+				mclassdef.mclass.inherit_init_from = inhc
+				self.toolcontext.info("{mclassdef} inherits all constructors from {inhc}", 3)
+				return
+			end
 			nclassdef.super_inits = combine
+			var mprop = new MMethod(mclassdef, "init", mclassdef.mclass.visibility)
+			var mpropdef = new MMethodDef(mclassdef, mprop, nclassdef.location)
+			var msignature = new MSignature(mparameters, null)
+			mpropdef.msignature = msignature
+			mprop.is_init = true
+			nclassdef.mfree_init = mpropdef
+			self.toolcontext.info("{mclassdef} gets a free empty constructor {mpropdef}{msignature}", 3)
+			return
+		end
+
+		if the_root_init_mmethod == null then return
+
+		# Look for nost-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`?")
 		end
 
-		var mprop = new MMethod(mclassdef, "init", mclassdef.mclass.visibility)
+		# Search the longest-one and checks for conflict
+		var longest = spropdefs.first
+		if spropdefs.length > 1 then
+			# Check for conflict in the order of initializers
+			# Each initializer list must me a prefix of the longest list
+			# part 1. find the longest list
+			for spd in spropdefs do
+				if spd.initializers.length > longest.initializers.length then longest = spd
+			end
+			# part 2. compare
+			for spd in spropdefs do
+				var i = 0
+				for p in spd.initializers do
+					if p != longest.initializers[i] then
+						self.error(nclassdef, "Error: conflict for inherited inits {spd}({spd.initializers.join(", ")}) and {longest}({longest.initializers.join(", ")})")
+						return
+					end
+					i += 1
+				end
+			end
+		end
+
+		# Can we just inherit?
+		if spropdefs.length == 1 and mparameters.is_empty and defined_init == null then
+			self.toolcontext.info("{mclassdef} inherits the basic constructor {longest}", 3)
+			return
+		end
+
+		# Combine the inherited list to what is collected
+		if longest.initializers.length > 0 then
+			mparameters.prepend longest.new_msignature.mparameters
+			initializers.prepend longest.initializers
+		end
+
+		# If we already have a basic init definition, then setup its initializers
+		if defined_init != null then
+			defined_init.initializers.add_all(initializers)
+			var msignature = new MSignature(mparameters, null)
+			defined_init.new_msignature = msignature
+			self.toolcontext.info("{mclassdef} extends its basic constructor signature to {defined_init}{msignature}", 3)
+			return
+		end
+
+		# Else create the local implicit basic init definition
+		var mprop = the_root_init_mmethod.as(not null)
 		var mpropdef = new MMethodDef(mclassdef, mprop, nclassdef.location)
+		mpropdef.has_supercall = true
+		mpropdef.initializers.add_all(initializers)
 		var msignature = new MSignature(mparameters, null)
-		mpropdef.msignature = msignature
-		mprop.is_init = true
+		mpropdef.new_msignature = msignature
+		mpropdef.msignature = new MSignature(new Array[MParameter], null) # always an empty real signature
 		nclassdef.mfree_init = mpropdef
 		self.toolcontext.info("{mclassdef} gets a free constructor for attributes {mpropdef}{msignature}", 3)
 	end
@@ -154,7 +289,7 @@ redef class ModelBuilder
 		# It is a case-by case
 		var vis_type: nullable MVisibility = null # The own visibility of the type
 		var mmodule_type: nullable MModule = null # The origial module of the type
-		if mtype isa MNullableType then mtype = mtype.mtype
+		mtype = mtype.as_notnullable
 		if mtype isa MClassType then
 			vis_type = mtype.mclass.visibility
 			mmodule_type = mtype.mclass.intro.mmodule
@@ -182,7 +317,11 @@ redef class ModelBuilder
 
 		# No error, try to go deeper in generic types
 		if node isa AType then
-			for a in node.n_types do check_visibility(a, a.mtype.as(not null), mpropdef)
+			for a in node.n_types do
+				var t = a.mtype
+				if t == null then continue # Error, thus skipped
+				check_visibility(a, t, mpropdef)
+			end
 		else if mtype isa MGenericType then
 			for t in mtype.arguments do check_visibility(node, t, mpropdef)
 		end
@@ -195,10 +334,6 @@ redef class MClass
 	var inherit_init_from: nullable MClass = null
 end
 
-redef class MClassDef
-	private var propdef_names = new HashSet[String]
-end
-
 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
@@ -213,7 +348,9 @@ redef class AClassdef
 
 	# The free init (implicitely constructed by the class if required)
 	var mfree_init: nullable MMethodDef = null
+end
 
+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]
@@ -248,10 +385,10 @@ redef class APropdef
 	# The associated propdef once build by a `ModelBuilder`
 	var mpropdef: nullable MPROPDEF writable
 
-	private fun build_property(modelbuilder: ModelBuilder, nclassdef: AClassdef) is abstract
-	private fun build_signature(modelbuilder: ModelBuilder, nclassdef: AClassdef) is abstract
-	private fun check_signature(modelbuilder: ModelBuilder, nclassdef: AClassdef) is abstract
-	private fun new_property_visibility(modelbuilder: ModelBuilder, nclassdef: AClassdef, nvisibility: nullable AVisibility): MVisibility
+	private fun build_property(modelbuilder: ModelBuilder, mclassdef: MClassDef) is abstract
+	private fun build_signature(modelbuilder: ModelBuilder) is abstract
+	private fun check_signature(modelbuilder: ModelBuilder) is abstract
+	private fun new_property_visibility(modelbuilder: ModelBuilder, mclassdef: MClassDef, nvisibility: nullable AVisibility): MVisibility
 	do
 		var mvisibility = public_visibility
 		if nvisibility != null then
@@ -261,7 +398,7 @@ redef class APropdef
 				mvisibility = public_visibility
 			end
 		end
-		if nclassdef.mclassdef.mclass.visibility == private_visibility then
+		if mclassdef.mclass.visibility == private_visibility then
 			if mvisibility == protected_visibility then
 				assert nvisibility != null
 				modelbuilder.error(nvisibility, "Error: The only legal visibility for properties in a private class is private.")
@@ -278,10 +415,14 @@ redef class APropdef
 	private fun set_doc(mpropdef: MPropDef)
 	do
 		var ndoc = self.n_doc
-		if ndoc != null then mpropdef.mdoc = ndoc.to_mdoc
+		if ndoc != null then
+			var mdoc = ndoc.to_mdoc
+			mpropdef.mdoc = mdoc
+			mdoc.original_mentity = mpropdef
+		end
 	end
 
-	private fun check_redef_property_visibility(modelbuilder: ModelBuilder, nclassdef: AClassdef, nvisibility: nullable AVisibility, mprop: MProperty)
+	private fun check_redef_property_visibility(modelbuilder: ModelBuilder, nvisibility: nullable AVisibility, mprop: MProperty)
 	do
 		if nvisibility == null then return
 		var mvisibility = nvisibility.mvisibility
@@ -290,20 +431,29 @@ redef class APropdef
 		end
 	end
 
-	private fun check_redef_keyword(modelbuilder: ModelBuilder, nclassdef: AClassdef, kwredef: nullable Token, need_redef: Bool, mprop: MProperty): Bool
+	private fun check_redef_keyword(modelbuilder: ModelBuilder, mclassdef: MClassDef, kwredef: nullable Token, need_redef: Bool, mprop: MProperty): Bool
 	do
-		if nclassdef.mprop2npropdef.has_key(mprop) then
-			modelbuilder.error(self, "Error: A property {mprop} is already defined in class {nclassdef.mclassdef.mclass}.")
+		if mclassdef.mprop2npropdef.has_key(mprop) then
+			modelbuilder.error(self, "Error: A property {mprop} is already defined in class {mclassdef.mclass} at line {mclassdef.mprop2npropdef[mprop].location.line_start}.")
 			return false
 		end
+		if mprop isa MMethod and mprop.is_toplevel != (parent isa ATopClassdef) then
+			if mprop.is_toplevel then
+				modelbuilder.error(self, "Error: {mprop} is a top level method.")
+			else
+				modelbuilder.error(self, "Error: {mprop} is not a top level method.")
+			end
+			return false
+
+		end
 		if kwredef == null then
 			if need_redef then
-				modelbuilder.error(self, "Redef error: {nclassdef.mclassdef.mclass}::{mprop.name} is an inherited property. To redefine it, add the redef keyword.")
+				modelbuilder.error(self, "Redef error: {mclassdef.mclass}::{mprop.name} is an inherited property. To redefine it, add the redef keyword.")
 				return false
 			end
 		else
 			if not need_redef then
-				modelbuilder.error(self, "Error: No property {nclassdef.mclassdef.mclass}::{mprop.name} is inherited. Remove the redef keyword to define a new property.")
+				modelbuilder.error(self, "Error: No property {mclassdef.mclass}::{mprop.name} is inherited. Remove the redef keyword to define a new property.")
 				return false
 			end
 		end
@@ -328,15 +478,16 @@ redef class ASignature
 	var ret_type: nullable MType = null
 
 	# Visit and fill information about a signature
-	private fun visit_signature(modelbuilder: ModelBuilder, nclassdef: AClassdef): Bool
+	private fun visit_signature(modelbuilder: ModelBuilder, mclassdef: MClassDef): Bool
 	do
+		var mmodule = mclassdef.mmodule
 		var param_names = self.param_names
 		var param_types = self.param_types
 		for np in self.n_params do
 			param_names.add(np.n_id.text)
 			var ntype = np.n_type
 			if ntype != null then
-				var mtype = modelbuilder.resolve_mtype(nclassdef, ntype)
+				var mtype = modelbuilder.resolve_mtype(mmodule, mclassdef, ntype)
 				if mtype == null then return false # Skip error
 				for i in [0..param_names.length-param_types.length[ do
 					param_types.add(mtype)
@@ -353,7 +504,7 @@ redef class ASignature
 		end
 		var ntype = self.n_type
 		if ntype != null then
-			self.ret_type = modelbuilder.resolve_mtype(nclassdef, ntype)
+			self.ret_type = modelbuilder.resolve_mtype(mmodule, mclassdef, ntype)
 			if self.ret_type == null then return false # Skip errir
 		end
 
@@ -362,7 +513,7 @@ redef class ASignature
 	end
 
 	# Build a visited signature
-	fun build_signature(modelbuilder: ModelBuilder, nclassdef: AClassdef): nullable MSignature
+	fun build_signature(modelbuilder: ModelBuilder): nullable MSignature
 	do
 		if param_names.length != param_types.length then
 			# Some parameters are typed, other parameters are not typed.
@@ -390,12 +541,36 @@ end
 redef class AMethPropdef
 	redef type MPROPDEF: MMethodDef
 
-	redef fun build_property(modelbuilder, nclassdef)
+
+	# Can self be used as a root init?
+	private fun look_like_a_root_init(modelbuilder: ModelBuilder): 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
+		var amod = self.parent.parent.as(AModule)
+		var amoddecl = amod.n_moduledecl
+		if amoddecl != null then
+			var old = amoddecl.get_single_annotation("old_style_init", modelbuilder)
+			if old != null then return false
+		end
+
+		return true
+	end
+
+	redef fun build_property(modelbuilder, mclassdef)
 	do
 		var n_kwinit = n_kwinit
 		var n_kwnew = n_kwnew
 		var is_init = n_kwinit != null or n_kwnew != null
-		var mclassdef = nclassdef.mclassdef.as(not null)
 		var name: String
 		var amethodid = self.n_methid
 		var name_node: ANode
@@ -427,40 +602,28 @@ redef class AMethPropdef
 
 		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
+			mprop = modelbuilder.the_root_init_mmethod
+		end
 		if mprop == null then
-			var mvisibility = new_property_visibility(modelbuilder, nclassdef, self.n_visibility)
+			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
+				modelbuilder.the_root_init_mmethod = mprop
+				mprop.is_root_init = true
+			end
 			mprop.is_init = is_init
 			mprop.is_new = n_kwnew != null
-			if not self.check_redef_keyword(modelbuilder, nclassdef, n_kwredef, false, mprop) then return
+			if parent isa ATopClassdef then mprop.is_toplevel = true
+			if not self.check_redef_keyword(modelbuilder, mclassdef, n_kwredef, false, mprop) then return
 		else
-			if n_kwredef == null then
-				if self isa AMainMethPropdef then
-					# no warning
-				else
-					if not self.check_redef_keyword(modelbuilder, nclassdef, n_kwredef, true, mprop) then return
-				end
-			end
-			check_redef_property_visibility(modelbuilder, nclassdef, self.n_visibility, mprop)
+			if not mprop.is_root_init and 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
-		nclassdef.mprop2npropdef[mprop] = self
+		mclassdef.mprop2npropdef[mprop] = self
 
 		var mpropdef = new MMethodDef(mclassdef, mprop, self.location)
 
-		if mclassdef.propdef_names.has(mprop.name) then
-			var loc: nullable Location = null
-			for i in mclassdef.mpropdefs do
-				if i.mproperty.name == mprop.name then
-					loc = i.location
-					break
-				end
-			end
-			if loc == null then abort
-			modelbuilder.error(self, "Error: a property {mprop} is already defined in class {mclassdef.mclass} at {loc}")
-		end
-
-		mclassdef.propdef_names.add(mpropdef.mproperty.name)
-
 		set_doc(mpropdef)
 
 		self.mpropdef = mpropdef
@@ -472,11 +635,12 @@ redef class AMethPropdef
 		end
 	end
 
-	redef fun build_signature(modelbuilder, nclassdef)
+	redef fun build_signature(modelbuilder)
 	do
 		var mpropdef = self.mpropdef
 		if mpropdef == null then return # Error thus skiped
-		var mmodule = mpropdef.mclassdef.mmodule
+		var mclassdef = mpropdef.mclassdef
+		var mmodule = mclassdef.mmodule
 		var nsig = self.n_signature
 
 		# Retrieve info from the signature AST
@@ -485,7 +649,7 @@ redef class AMethPropdef
 		var vararg_rank = -1
 		var ret_type: nullable MType = null # Return type from the AST
 		if nsig != null then
-			if not nsig.visit_signature(modelbuilder, nclassdef) then return
+			if not nsig.visit_signature(modelbuilder, mclassdef) then return
 			param_names = nsig.param_names
 			param_types = nsig.param_types
 			vararg_rank = nsig.vararg_rank
@@ -508,8 +672,8 @@ redef class AMethPropdef
 			end
 		else if mpropdef.mproperty.is_init then
 			# FIXME UGLY: inherit signature from a super-constructor
-			for msupertype in nclassdef.mclassdef.supertypes do
-				msupertype = msupertype.anchor_to(mmodule, nclassdef.mclassdef.bound_mtype)
+			for msupertype in mclassdef.supertypes do
+				msupertype = msupertype.anchor_to(mmodule, mclassdef.bound_mtype)
 				var candidate = modelbuilder.try_get_mproperty_by_name2(self, mmodule, msupertype, mpropdef.mproperty.name)
 				if candidate != null then
 					if msignature == null then
@@ -553,11 +717,12 @@ redef class AMethPropdef
 		mpropdef.is_extern = self isa AExternPropdef
 	end
 
-	redef fun check_signature(modelbuilder, nclassdef)
+	redef fun check_signature(modelbuilder)
 	do
 		var mpropdef = self.mpropdef
 		if mpropdef == null then return # Error thus skiped
-		var mmodule = mpropdef.mclassdef.mmodule
+		var mclassdef = mpropdef.mclassdef
+		var mmodule = mclassdef.mmodule
 		var nsig = self.n_signature
 		var mysignature = self.mpropdef.msignature
 		if mysignature == null then return # Error thus skiped
@@ -580,8 +745,8 @@ redef class AMethPropdef
 				for i in [0..mysignature.arity[ do
 					var myt = mysignature.mparameters[i].mtype
 					var prt = msignature.mparameters[i].mtype
-					if not myt.is_subtype(mmodule, nclassdef.mclassdef.bound_mtype, prt) or
-							not prt.is_subtype(mmodule, nclassdef.mclassdef.bound_mtype, myt) then
+					if not myt.is_subtype(mmodule, mclassdef.bound_mtype, prt) or
+							not prt.is_subtype(mmodule, mclassdef.bound_mtype, myt) then
 						modelbuilder.error(nsig.n_params[i], "Redef Error: Wrong type for parameter `{mysignature.mparameters[i].name}'. found {myt}, expected {prt} as in {mpropdef.mproperty.intro}.")
 					end
 				end
@@ -590,7 +755,7 @@ redef class AMethPropdef
 				if ret_type == null then
 					# Inherit the return type
 					ret_type = precursor_ret_type
-				else if not ret_type.is_subtype(mmodule, nclassdef.mclassdef.bound_mtype, precursor_ret_type) then
+				else if not ret_type.is_subtype(mmodule, mclassdef.bound_mtype, precursor_ret_type) then
 					modelbuilder.error(nsig.n_type.as(not null), "Redef Error: Wrong return type. found {ret_type}, expected {precursor_ret_type} as in {mpropdef.mproperty.intro}.")
 				end
 			end
@@ -611,13 +776,25 @@ end
 redef class AAttrPropdef
 	redef type MPROPDEF: MAttributeDef
 
+	# Is the node tagged `noinit`?
+	var noinit = false
+
+	# Is the node taggeg lazy?
+	var is_lazy = false
+
+	# The guard associated to a lasy attribute.
+	# Because some engines does not have a working `isset`,
+	# this additionnal attribute is used to guard the lazy initialization.
+	# TODO: to remove once isset is correctly implemented
+	var mlazypropdef: nullable MAttributeDef
+
 	# The associated getter (read accessor) if any
 	var mreadpropdef: nullable MMethodDef writable
 	# The associated setter (write accessor) if any
 	var mwritepropdef: nullable MMethodDef writable
-	redef fun build_property(modelbuilder, nclassdef)
+
+	redef fun build_property(modelbuilder, mclassdef)
 	do
-		var mclassdef = nclassdef.mclassdef.as(not null)
 		var mclass = mclassdef.mclass
 
 		var name: String
@@ -640,15 +817,15 @@ redef class AAttrPropdef
 			# Old attribute style
 			var mprop = modelbuilder.try_get_mproperty_by_name(nid, mclassdef, name)
 			if mprop == null then
-				var mvisibility = new_property_visibility(modelbuilder, nclassdef, self.n_visibility)
+				var mvisibility = new_property_visibility(modelbuilder, mclassdef, self.n_visibility)
 				mprop = new MAttribute(mclassdef, name, mvisibility)
-				if not self.check_redef_keyword(modelbuilder, nclassdef, self.n_kwredef, false, mprop) then return
+				if not self.check_redef_keyword(modelbuilder, mclassdef, self.n_kwredef, false, mprop) then return
 			else
 				assert mprop isa MAttribute
-				check_redef_property_visibility(modelbuilder, nclassdef, self.n_visibility, mprop)
-				if not self.check_redef_keyword(modelbuilder, nclassdef, self.n_kwredef, true, mprop) then return
+				check_redef_property_visibility(modelbuilder, self.n_visibility, mprop)
+				if not self.check_redef_keyword(modelbuilder, mclassdef, self.n_kwredef, true, mprop) then return
 			end
-			nclassdef.mprop2npropdef[mprop] = self
+			mclassdef.mprop2npropdef[mprop] = self
 
 			var mpropdef = new MAttributeDef(mclassdef, mprop, self.location)
 			self.mpropdef = mpropdef
@@ -656,48 +833,13 @@ redef class AAttrPropdef
 			set_doc(mpropdef)
 
 			var nreadable = self.n_readable
-			if nreadable != null then
-				var readname = name.substring_from(1)
-				var mreadprop = modelbuilder.try_get_mproperty_by_name(nid, mclassdef, readname).as(nullable MMethod)
-				if mreadprop == null then
-					var mvisibility = new_property_visibility(modelbuilder, nclassdef, nreadable.n_visibility)
-					mreadprop = new MMethod(mclassdef, readname, mvisibility)
-					if not self.check_redef_keyword(modelbuilder, nclassdef, nreadable.n_kwredef, false, mreadprop) then return
-				else
-					if not self.check_redef_keyword(modelbuilder, nclassdef, nreadable.n_kwredef, true, mreadprop) then return
-					check_redef_property_visibility(modelbuilder, nclassdef, nreadable.n_visibility, mreadprop)
-				end
-				nclassdef.mprop2npropdef[mreadprop] = self
-
-				var mreadpropdef = new MMethodDef(mclassdef, mreadprop, self.location)
-				self.mreadpropdef = mreadpropdef
-				modelbuilder.mpropdef2npropdef[mreadpropdef] = self
-				mreadpropdef.mdoc = mpropdef.mdoc
-			end
-
+			if nreadable != null then modelbuilder.error(nreadable, "Error: old-style getter no more supported")
 			var nwritable = self.n_writable
-			if nwritable != null then
-				var writename = name.substring_from(1) + "="
-				var mwriteprop = modelbuilder.try_get_mproperty_by_name(nid, mclassdef, writename).as(nullable MMethod)
-				if mwriteprop == null then
-					var mvisibility = new_property_visibility(modelbuilder, nclassdef, nwritable.n_visibility)
-					mwriteprop = new MMethod(mclassdef, writename, mvisibility)
-					if not self.check_redef_keyword(modelbuilder, nclassdef, nwritable.n_kwredef, false, mwriteprop) then return
-				else
-					if not self.check_redef_keyword(modelbuilder, nclassdef, nwritable.n_kwredef, true, mwriteprop) then return
-					check_redef_property_visibility(modelbuilder, nclassdef, nwritable.n_visibility, mwriteprop)
-				end
-				nclassdef.mprop2npropdef[mwriteprop] = self
-
-				var mwritepropdef = new MMethodDef(mclassdef, mwriteprop, self.location)
-				self.mwritepropdef = mwritepropdef
-				modelbuilder.mpropdef2npropdef[mwritepropdef] = self
-				mwritepropdef.mdoc = mpropdef.mdoc
-			end
+			if nwritable != null then modelbuilder.error(nwritable, "Error: old-style setter no more supported")
 		else
 			# New attribute style
 			var nid2 = self.n_id2.as(not null)
-			var mprop = new MAttribute(mclassdef, "@" + name, none_visibility)
+			var mprop = new MAttribute(mclassdef, "_" + name, private_visibility)
 			var mpropdef = new MAttributeDef(mclassdef, mprop, self.location)
 			self.mpropdef = mpropdef
 			modelbuilder.mpropdef2npropdef[mpropdef] = self
@@ -706,41 +848,72 @@ redef class AAttrPropdef
 			var readname = name
 			var mreadprop = modelbuilder.try_get_mproperty_by_name(nid2, mclassdef, readname).as(nullable MMethod)
 			if mreadprop == null then
-				var mvisibility = new_property_visibility(modelbuilder, nclassdef, self.n_visibility)
+				var mvisibility = new_property_visibility(modelbuilder, mclassdef, self.n_visibility)
 				mreadprop = new MMethod(mclassdef, readname, mvisibility)
-				if not self.check_redef_keyword(modelbuilder, nclassdef, n_kwredef, false, mreadprop) then return
+				if not self.check_redef_keyword(modelbuilder, mclassdef, n_kwredef, false, mreadprop) then return
 			else
-				if not self.check_redef_keyword(modelbuilder, nclassdef, n_kwredef, true, mreadprop) then return
-				check_redef_property_visibility(modelbuilder, nclassdef, self.n_visibility, mreadprop)
+				if not self.check_redef_keyword(modelbuilder, mclassdef, n_kwredef, true, mreadprop) then return
+				check_redef_property_visibility(modelbuilder, self.n_visibility, mreadprop)
 			end
-			nclassdef.mprop2npropdef[mreadprop] = self
+			mclassdef.mprop2npropdef[mreadprop] = self
 
 			var mreadpropdef = new MMethodDef(mclassdef, mreadprop, self.location)
 			self.mreadpropdef = mreadpropdef
 			modelbuilder.mpropdef2npropdef[mreadpropdef] = self
 			mreadpropdef.mdoc = mpropdef.mdoc
 
+			var atlazy = self.get_single_annotation("lazy", modelbuilder)
+			if atlazy != null then
+				if n_expr == null then
+					modelbuilder.error(atlazy, "Error: a lazy attribute needs a value")
+				end
+				is_lazy = true
+				var mlazyprop = new MAttribute(mclassdef, "lazy _" + name, none_visibility)
+				var mlazypropdef = new MAttributeDef(mclassdef, mlazyprop, self.location)
+				self.mlazypropdef = mlazypropdef
+			end
+
+			var atreadonly = self.get_single_annotation("readonly", modelbuilder)
+			if atreadonly != null then
+				if n_expr == null then
+					modelbuilder.error(atreadonly, "Error: a readonly attribute needs a value")
+				end
+				# No setter, so just leave
+				return
+			end
+
 			var writename = name + "="
 			var nwritable = self.n_writable
+			var atwritable = self.get_single_annotation("writable", modelbuilder)
+			if atwritable != null then
+				if not atwritable.n_args.is_empty then
+					writename = atwritable.arg_as_id(modelbuilder) or else writename
+				end
+			end
 			var mwriteprop = modelbuilder.try_get_mproperty_by_name(nid2, mclassdef, writename).as(nullable MMethod)
 			var nwkwredef: nullable Token = null
 			if nwritable != null then nwkwredef = nwritable.n_kwredef
+			if atwritable != null then nwkwredef = atwritable.n_kwredef
 			if mwriteprop == null then
 				var mvisibility
 				if nwritable != null then
-					mvisibility = new_property_visibility(modelbuilder, nclassdef, nwritable.n_visibility)
+					mvisibility = new_property_visibility(modelbuilder, mclassdef, nwritable.n_visibility)
+				else if atwritable != null then
+					mvisibility = new_property_visibility(modelbuilder, mclassdef, atwritable.n_visibility)
 				else
 					mvisibility = private_visibility
 				end
 				mwriteprop = new MMethod(mclassdef, writename, mvisibility)
-				if not self.check_redef_keyword(modelbuilder, nclassdef, nwkwredef, false, mwriteprop) then return
+				if not self.check_redef_keyword(modelbuilder, mclassdef, nwkwredef, false, mwriteprop) then return
 			else
-				if not self.check_redef_keyword(modelbuilder, nclassdef, nwkwredef, true, mwriteprop) then return
+				if not self.check_redef_keyword(modelbuilder, mclassdef, nwkwredef or else n_kwredef, true, mwriteprop) then return
 				if nwritable != null then
-					check_redef_property_visibility(modelbuilder, nclassdef, nwritable.n_visibility, mwriteprop)
+					check_redef_property_visibility(modelbuilder, nwritable.n_visibility, mwriteprop)
+				else if atwritable != null then
+					check_redef_property_visibility(modelbuilder, atwritable.n_visibility, mwriteprop)
 				end
 			end
-			nclassdef.mprop2npropdef[mwriteprop] = self
+			mclassdef.mprop2npropdef[mwriteprop] = self
 
 			var mwritepropdef = new MMethodDef(mclassdef, mwriteprop, self.location)
 			self.mwritepropdef = mwritepropdef
@@ -749,24 +922,34 @@ redef class AAttrPropdef
 		end
 	end
 
-	redef fun build_signature(modelbuilder, nclassdef)
+	redef fun build_signature(modelbuilder)
 	do
 		var mpropdef = self.mpropdef
 		if mpropdef == null then return # Error thus skiped
-		var mmodule = mpropdef.mclassdef.mmodule
+		var mclassdef = mpropdef.mclassdef
+		var mmodule = mclassdef.mmodule
 		var mtype: nullable MType = null
 
+		var mreadpropdef = self.mreadpropdef
+
 		var ntype = self.n_type
 		if ntype != null then
-			mtype = modelbuilder.resolve_mtype(nclassdef, ntype)
+			mtype = modelbuilder.resolve_mtype(mmodule, mclassdef, ntype)
 			if mtype == null then return
 		end
 
+		# Inherit the type from the getter (usually an abstact getter)
+		if mtype == null and mreadpropdef != null and not mreadpropdef.is_intro then
+			var msignature = mreadpropdef.mproperty.intro.msignature
+			if msignature == null then return # Error, thus skiped
+			mtype = msignature.return_mtype
+		end
+
 		var nexpr = self.n_expr
 		if mtype == null then
 			if nexpr != null then
 				if nexpr isa ANewExpr then
-					mtype = modelbuilder.resolve_mtype(nclassdef, nexpr.n_type)
+					mtype = modelbuilder.resolve_mtype(mmodule, mclassdef, nexpr.n_type)
 				else if nexpr isa AIntExpr then
 					var cla = modelbuilder.try_get_mclass_by_name(nexpr, mmodule, "Int")
 					if cla != null then mtype = cla.mclass_type
@@ -789,30 +972,30 @@ redef class AAttrPropdef
 					modelbuilder.error(self, "Error: Untyped attribute {mpropdef}. Implicit typing allowed only for literals and new.")
 				end
 
-			else
-				modelbuilder.error(self, "Error: Untyped attribute {mpropdef}")
+				if mtype == null then return
 			end
-		else
-			assert ntype != null
+		else if ntype != null then
 			if nexpr isa ANewExpr then
-				var xmtype = modelbuilder.resolve_mtype(nclassdef, nexpr.n_type)
+				var xmtype = modelbuilder.resolve_mtype(mmodule, mclassdef, nexpr.n_type)
 				if xmtype == mtype and modelbuilder.toolcontext.opt_warn.value >= 2 then
 					modelbuilder.warning(ntype, "Warning: useless type definition")
 				end
 			end
 		end
 
-		if mtype == null then return
+		if mtype == null then
+			modelbuilder.error(self, "Error: Untyped attribute {mpropdef}")
+			return
+		end
 
 		mpropdef.static_mtype = mtype
 
-		var mreadpropdef = self.mreadpropdef
 		if mreadpropdef != null then
 			var msignature = new MSignature(new Array[MParameter], mtype)
 			mreadpropdef.msignature = msignature
 		end
 
-		var msritepropdef = self.mwritepropdef
+		var mwritepropdef = self.mwritepropdef
 		if mwritepropdef != null then
 			var name: String
 			if n_id != null then
@@ -824,13 +1007,19 @@ redef class AAttrPropdef
 			var msignature = new MSignature([mparameter], null)
 			mwritepropdef.msignature = msignature
 		end
+
+		var mlazypropdef = self.mlazypropdef
+		if mlazypropdef != null then
+			mlazypropdef.static_mtype = modelbuilder.model.get_mclasses_by_name("Bool").first.mclass_type
+		end
 	end
 
-	redef fun check_signature(modelbuilder, nclassdef)
+	redef fun check_signature(modelbuilder)
 	do
 		var mpropdef = self.mpropdef
 		if mpropdef == null then return # Error thus skiped
-		var mmodule = mpropdef.mclassdef.mmodule
+		var mclassdef = mpropdef.mclassdef
+		var mmodule = mclassdef.mmodule
 		var ntype = self.n_type
 		var mtype = self.mpropdef.static_mtype
 		if mtype == null then return # Error thus skiped
@@ -850,23 +1039,24 @@ redef class AAttrPropdef
 		# Check getter and setter
 		var meth = self.mreadpropdef
 		if meth != null then
-			self.check_method_signature(modelbuilder, nclassdef, meth)
+			self.check_method_signature(modelbuilder, meth)
 			var node: nullable ANode = ntype
 			if node == null then node = self
 			modelbuilder.check_visibility(node, mtype, meth)
 		end
 		meth = self.mwritepropdef
 		if meth != null then
-			self.check_method_signature(modelbuilder, nclassdef, meth)
+			self.check_method_signature(modelbuilder, meth)
 			var node: nullable ANode = ntype
 			if node == null then node = self
 			modelbuilder.check_visibility(node, mtype, meth)
 		end
 	end
 
-	private fun check_method_signature(modelbuilder: ModelBuilder, nclassdef: AClassdef, mpropdef: MMethodDef)
+	private fun check_method_signature(modelbuilder: ModelBuilder, mpropdef: MMethodDef)
 	do
-		var mmodule = mpropdef.mclassdef.mmodule
+		var mclassdef = mpropdef.mclassdef
+		var mmodule = mclassdef.mmodule
 		var nsig = self.n_type
 		var mysignature = mpropdef.msignature
 		if mysignature == null then return # Error thus skiped
@@ -897,8 +1087,8 @@ redef class AAttrPropdef
 				for i in [0..mysignature.arity[ do
 					var myt = mysignature.mparameters[i].mtype
 					var prt = msignature.mparameters[i].mtype
-					if not myt.is_subtype(mmodule, nclassdef.mclassdef.bound_mtype, prt) and
-							not prt.is_subtype(mmodule, nclassdef.mclassdef.bound_mtype, myt) then
+					if not myt.is_subtype(mmodule, mclassdef.bound_mtype, prt) or
+							not prt.is_subtype(mmodule, mclassdef.bound_mtype, myt) then
 						var node: ANode
 						if nsig != null then node = nsig else node = self
 						modelbuilder.error(node, "Redef Error: Wrong type for parameter `{mysignature.mparameters[i].name}'. found {myt}, expected {prt}.")
@@ -909,7 +1099,7 @@ redef class AAttrPropdef
 				if ret_type == null then
 					# Inherit the return type
 					ret_type = precursor_ret_type
-				else if not ret_type.is_subtype(mmodule, nclassdef.mclassdef.bound_mtype, precursor_ret_type) then
+				else if not ret_type.is_subtype(mmodule, mclassdef.bound_mtype, precursor_ret_type) then
 					var node: ANode
 					if nsig != null then node = nsig else node = self
 					modelbuilder.error(node, "Redef Error: Wrong return type. found {ret_type}, expected {precursor_ret_type}.")
@@ -922,48 +1112,53 @@ end
 redef class ATypePropdef
 	redef type MPROPDEF: MVirtualTypeDef
 
-	redef fun build_property(modelbuilder, nclassdef)
+	redef fun build_property(modelbuilder, mclassdef)
 	do
-		var mclassdef = nclassdef.mclassdef.as(not null)
 		var name = self.n_id.text
 		var mprop = modelbuilder.try_get_mproperty_by_name(self.n_id, mclassdef, name)
 		if mprop == null then
-			var mvisibility = new_property_visibility(modelbuilder, nclassdef, self.n_visibility)
+			var mvisibility = new_property_visibility(modelbuilder, mclassdef, self.n_visibility)
 			mprop = new MVirtualTypeProp(mclassdef, name, mvisibility)
 			for c in name.chars do if c >= 'a' and c<= 'z' then
 				modelbuilder.warning(n_id, "Warning: lowercase in the virtual type {name}")
 				break
 			end
-			if not self.check_redef_keyword(modelbuilder, nclassdef, self.n_kwredef, false, mprop) then return
+			if not self.check_redef_keyword(modelbuilder, mclassdef, self.n_kwredef, false, mprop) then return
 		else
-			if not self.check_redef_keyword(modelbuilder, nclassdef, self.n_kwredef, true, mprop) then return
+			if not self.check_redef_keyword(modelbuilder, mclassdef, self.n_kwredef, true, mprop) then return
 			assert mprop isa MVirtualTypeProp
-			check_redef_property_visibility(modelbuilder, nclassdef, self.n_visibility, mprop)
+			check_redef_property_visibility(modelbuilder, self.n_visibility, mprop)
 		end
-		nclassdef.mprop2npropdef[mprop] = self
+		mclassdef.mprop2npropdef[mprop] = self
 
 		var mpropdef = new MVirtualTypeDef(mclassdef, mprop, self.location)
 		self.mpropdef = mpropdef
 		modelbuilder.mpropdef2npropdef[mpropdef] = self
 		set_doc(mpropdef)
+
+		var atfixed = get_single_annotation("fixed", modelbuilder)
+		if atfixed != null then
+			mpropdef.is_fixed = true
+		end
 	end
 
-	redef fun build_signature(modelbuilder, nclassdef)
+	redef fun build_signature(modelbuilder)
 	do
 		var mpropdef = self.mpropdef
 		if mpropdef == null then return # Error thus skiped
-		var mmodule = mpropdef.mclassdef.mmodule
+		var mclassdef = mpropdef.mclassdef
+		var mmodule = mclassdef.mmodule
 		var mtype: nullable MType = null
 
 		var ntype = self.n_type
-		mtype = modelbuilder.resolve_mtype(nclassdef, ntype)
+		mtype = modelbuilder.resolve_mtype(mmodule, mclassdef, ntype)
 		if mtype == null then return
 
 		mpropdef.bound = mtype
 		# print "{mpropdef}: {mtype}"
 	end
 
-	redef fun check_signature(modelbuilder, nclassdef)
+	redef fun check_signature(modelbuilder)
 	do
 		var mpropdef = self.mpropdef
 		if mpropdef == null then return # Error thus skiped
@@ -971,26 +1166,46 @@ redef class ATypePropdef
 		var bound = self.mpropdef.bound
 		if bound == null then return # Error thus skiped
 
-		modelbuilder.check_visibility(n_type.as(not null), bound, mpropdef)
-
-		# Fast case: the bound is not a formal type
-		if not bound isa MVirtualType then return
-
-		var mmodule = nclassdef.mclassdef.mmodule
-		var anchor = nclassdef.mclassdef.bound_mtype
-
-		# Slow case: progress on each resolution until: (i) we loop, or (ii) we found a non formal type
-		var seen = [self.mpropdef.mproperty.mvirtualtype]
-		loop
-			if seen.has(bound) then
+		modelbuilder.check_visibility(n_type, bound, mpropdef)
+
+		var mclassdef = mpropdef.mclassdef
+		var mmodule = mclassdef.mmodule
+		var anchor = mclassdef.bound_mtype
+
+		# Check circularity
+		if bound isa MVirtualType then
+			# Slow case: progress on each resolution until: (i) we loop, or (ii) we found a non formal type
+			var seen = [self.mpropdef.mproperty.mvirtualtype]
+			loop
+				if seen.has(bound) then
+					seen.add(bound)
+					modelbuilder.error(self, "Error: circularity of virtual type definition: {seen.join(" -> ")}")
+					return
+				end
 				seen.add(bound)
-				modelbuilder.error(self, "Error: circularity of virtual type definition: {seen.join(" -> ")}")
-				return
+				var next = bound.lookup_bound(mmodule, anchor)
+				if not next isa MVirtualType then break
+				bound = next
+			end
+		end
+
+		# 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)
+			if p.is_fixed then
+				modelbuilder.error(self, "Redef Error: Virtual type {mpropdef.mproperty} is fixed in super-class {p.mclassdef.mclass}")
+				break
+			end
+			if p.mclassdef.mclass == mclassdef.mclass then
+				# Still a warning to pass existing bad code
+				modelbuilder.warning(n_type, "Redef Error: a virtual type cannot be refined.")
+				break
+			end
+			if not bound.is_subtype(mmodule, anchor, supbound) then
+				modelbuilder.error(n_type, "Redef Error: Wrong bound type. Found {bound}, expected a subtype of {supbound}, as in {p}.")
+				break
 			end
-			seen.add(bound)
-			var next = bound.lookup_bound(mmodule, anchor)
-			if not next isa MVirtualType then break
-			bound = next
 		end
 	end
 end