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

diff --git a/src/modelize_property.nit b/src/modelize_property.nit
index 5a4ec42..db51cbd 100644
--- a/src/modelize_property.nit
+++ b/src/modelize_property.nit
@@ -18,6 +18,7 @@
 module modelize_property
 
 import modelize_class
+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
@@ -52,18 +54,25 @@ redef class ModelBuilder
 			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)
-		end
-		for npropdef in nclassdef.n_propdefs do
-			npropdef.check_signature(self)
+		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)
@@ -73,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 = 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, 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
@@ -109,15 +149,33 @@ 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
@@ -131,15 +189,14 @@ redef class ModelBuilder
 
 			# 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
@@ -149,13 +206,75 @@ redef class ModelBuilder
 				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
+
+		# 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
 
-		var mprop = new MMethod(mclassdef, "init", mclassdef.mclass.visibility)
+		# 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
@@ -170,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
@@ -198,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
@@ -211,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
@@ -229,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]
@@ -264,7 +385,7 @@ 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_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
@@ -310,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
@@ -411,12 +541,11 @@ end
 redef class AMethPropdef
 	redef type MPROPDEF: MMethodDef
 
-	redef fun build_property(modelbuilder, nclassdef)
+	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
@@ -453,35 +582,16 @@ redef class AMethPropdef
 			mprop = new MMethod(mclassdef, name, mvisibility)
 			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
+			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
-		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
@@ -634,13 +744,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
@@ -665,13 +787,13 @@ redef class AAttrPropdef
 			if mprop == null then
 				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, self.n_visibility, mprop)
-				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
 			end
-			nclassdef.mprop2npropdef[mprop] = self
+			mclassdef.mprop2npropdef[mprop] = self
 
 			var mpropdef = new MAttributeDef(mclassdef, mprop, self.location)
 			self.mpropdef = mpropdef
@@ -679,48 +801,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, mclassdef, 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, 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, mclassdef, 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, 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
@@ -731,39 +818,70 @@ redef class AAttrPropdef
 			if mreadprop == null then
 				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
+				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, 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, 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
@@ -780,12 +898,21 @@ redef class AAttrPropdef
 		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(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
@@ -813,11 +940,9 @@ 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(mmodule, mclassdef, nexpr.n_type)
 				if xmtype == mtype and modelbuilder.toolcontext.opt_warn.value >= 2 then
@@ -826,17 +951,19 @@ redef class AAttrPropdef
 			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
@@ -848,6 +975,11 @@ 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)
@@ -923,7 +1055,7 @@ 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, mclassdef.bound_mtype, prt) and
+					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
@@ -948,9 +1080,8 @@ 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
@@ -960,18 +1091,23 @@ redef class ATypePropdef
 				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, 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)
@@ -998,27 +1134,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
+		modelbuilder.check_visibility(n_type, bound, mpropdef)
 
 		var mclassdef = mpropdef.mclassdef
 		var mmodule = mclassdef.mmodule
 		var anchor = 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
+		# 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