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

diff --git a/src/syntax/mmbuilder.nit b/src/syntax/mmbuilder.nit
index 3a16ada..af4d0e2 100644
--- a/src/syntax/mmbuilder.nit
+++ b/src/syntax/mmbuilder.nit
@@ -24,7 +24,7 @@ import syntax_base
 # Class specialization hierarchy sorter
 private class CSHSorter
 special AbstractSorter[MMLocalClass]
-	redef meth compare(a, b)
+	redef fun compare(a, b)
 	do
 		return a.cshe.rank <=> b.cshe.rank
 	end
@@ -35,7 +35,7 @@ end
 redef class MMSrcModule
 	# Syntax analysis and MM construction for the module
 	# Require that supermodules are processed
-	meth do_mmbuilder(tc: ToolContext)
+	fun do_mmbuilder(tc: ToolContext)
 	do
 		# Import global classes
 		import_global_classes
@@ -123,18 +123,18 @@ end
 
 redef class MMLocalClass
 	# Accept a class visitor (on class nodes)
-	private meth accept_class_visitor(v: AbsSyntaxVisitor)
+	private fun accept_class_visitor(v: AbsSyntaxVisitor)
 	do
 	end
 
 	# Accept a class visitor (on class properties)
-	private meth accept_properties_visitor(v: AbsSyntaxVisitor)
+	private fun accept_properties_visitor(v: AbsSyntaxVisitor)
 	do
 	end
 end
 
 redef class MMSrcLocalClass
-	redef meth accept_class_visitor(v)
+	redef fun accept_class_visitor(v)
 	do
 		for n in nodes do
 			v.visit(n)
@@ -142,7 +142,7 @@ redef class MMSrcLocalClass
 	end
 
 	# Accept a class visitor (on class properties)
-	redef meth accept_properties_visitor(v)
+	redef fun accept_properties_visitor(v)
 	do
 		for n in nodes do
 			v.visit(n)
@@ -153,11 +153,8 @@ redef class MMSrcLocalClass
 		end
 	end
 
-	# A mixin class can be build the same way that one of its superclasses
-	readable attr _is_mixin: Bool = false
-
 	# Introduce or inherit default constructors
-	private meth process_default_constructors(v: PropertyBuilderVisitor)
+	private fun process_default_constructors(v: PropertyBuilderVisitor)
 	do
 		# Is there already a constructor ?
 		for gp in global_properties do
@@ -168,6 +165,7 @@ redef class MMSrcLocalClass
 		end
 
 		# Collect visible constructors in super stateful classes
+		var super_inits = new ArraySet[MMLocalProperty]
 		var super_constructors = new ArraySet[MMGlobalProperty]
 		for sc in che.direct_greaters do
 			if sc.global.is_universal or sc.global.is_interface then continue
@@ -175,6 +173,20 @@ redef class MMSrcLocalClass
 				if not gp.is_init then continue
 				super_constructors.add(gp)
 			end
+			var initname = once ("init".to_symbol)
+			if sc.has_global_property_by_name(initname) then
+				var gp = sc.get_property_by_name(initname)
+				super_inits.add(self[gp])
+			end
+		end
+
+		# Collect unassigned attributes
+		var unassigned_attributes = new Array[MMSrcAttribute]
+		for a in src_local_properties do
+			if a isa MMSrcAttribute then
+				var n = a.node
+				if n.n_expr == null then unassigned_attributes.add(a)
+			end
 		end
 
 		if not super_constructors.is_empty then
@@ -184,15 +196,14 @@ redef class MMSrcLocalClass
 			for gp in super_constructors do
 				var sc = gp.local_class
 				if supers.has(sc) then continue
-				assert sc isa MMSrcLocalClass
-				if not sc.is_mixin then
+				if not sc.global.is_mixin then
 					supers.add(sc)
 				end
 			end
 			supers = che.order.select_smallests(supers)
 
 			# A mixin class can only have 0 or 1 most specific non-mixin superclass
-			var superclass: MMLocalClass = null # This most specific non-mixin superclass (if any)
+			var superclass: nullable MMLocalClass = null # This most specific non-mixin superclass (if any)
 
 			if supers.length > 1 then
 				v.error(nodes.first, "Error: Explicit constructor required in {self} since multiple inheritance of constructor is forbiden. Conflicting classes are {supers.join(", ")}. Costructors are {super_constructors.join(", ")}.")
@@ -207,13 +218,20 @@ redef class MMSrcLocalClass
 					make_visible_an_inherited_global_property(gp)
 				end
 			end
-			_is_mixin = true
+			global.mixin_of = superclass.as(not null).global # FIXME Dear! this should break!
+		else
+			# v.error(nodes.first, "Error, constructor required in {self} since no anonimous init found in {sc}.")
+
+			# unassigned attributes, then implicit consructors are generated
+			var p = new MMImplicitInit(self, unassigned_attributes, super_inits.to_a)
+			add_src_local_property(v, p)
+			#print("Create implicit init {p} in {self} from {super_inits.join(", ")} + {unassigned_attributes.length} args")
 		end
 	end
 
 	# Add a source property
 	# Register it to the class and attach it to global property
-	private meth add_src_local_property(v: PropertyBuilderVisitor, prop: MMLocalProperty)
+	private fun add_src_local_property(v: PropertyBuilderVisitor, prop: MMLocalProperty)
 	do
 		var pname = prop.name
 		# Check double definition in the same class
@@ -225,15 +243,11 @@ redef class MMSrcLocalClass
 
 		# Intro or redefinition ?
 		if has_global_property_by_name(pname) then
-			var globs = properties_by_name[pname]
-			if globs.length > 1 then
-				v.error(prop.node, "Name error: {self} inherits {globs.length} global properties named {pname}.")
-			end
-			var g = globs.first
+			var g = get_property_by_name(pname)
 			prop.inherit_global(g)
 		end
 
-		if prop.global == null then
+		if not prop.is_global_set then
 			prop.new_global
 			prop.global.is_init = prop.is_init
 		end
@@ -241,16 +255,51 @@ redef class MMSrcLocalClass
 end
 
 redef class MMLocalProperty
-	private meth accept_property_visitor(v: AbsSyntaxVisitor)
+	private fun accept_property_visitor(v: AbsSyntaxVisitor)
 	do
 	end
 end
+
+redef class MMImplicitInit
+	readable var _super_init: nullable MMLocalProperty = null
+	redef fun accept_property_visitor(v)
+	do
+		var base: nullable MMLocalProperty = null
+		for p in super_inits do
+			if p.signature.arity > 0 then
+				if base == null then
+					base = p
+				else
+					v.error(null, "Error: explicit constructor needed in {local_class} since both super-constructor {base.full_name} and {p.full_name} have paramters")
+					return
+				end
+			end
+		end
+		_super_init = base
+
+		var params = new Array[MMType]
+		if base != null then
+			var sig = base.signature
+			for i in [0..sig.arity[ do
+				params.add(sig[i])
+			end
+		end
+		for a in unassigned_attributes do
+			var sig = a.signature
+			if sig == null then return # Broken attribute definition
+			params.add(sig.return_type.as(not null))
+		end
+		signature = new MMSignature(params, null, local_class.get_type)
+	end
+end
+
+
 # Concrete NIT class specialization relation
 class MMSrcAncestor
 special MMAncestor
 	# The related AST node
-	readable attr _node: ASuperclass
-	redef readable attr _local_class: MMLocalClass
+	readable var _node: ASuperclass
+	redef readable var _local_class: MMLocalClass
 
 	init(n: ASuperclass, c: MMLocalClass)
 	do
@@ -267,12 +316,12 @@ end
 private class ClassBuilderVisitor
 special AbsSyntaxVisitor
 	# Current class arity
-	readable writable attr _local_class_arity: Int 
+	readable writable var _local_class_arity: Int = 0
 
 	# Current class formal parameters
-	readable writable attr _formals: Map[Symbol, MMTypeFormalParameter] 
+	readable writable var _formals: nullable Map[Symbol, MMTypeFormalParameter]
 
-	redef meth visit(n) do n.accept_class_builder(self)
+	redef fun visit(n) do n.accept_class_builder(self)
 	init(tc, m) do super
 end
 
@@ -280,7 +329,7 @@ end
 # * Build ancertors (with only class informations not the type one)
 private class ClassSpecializationBuilderVisitor
 special AbsSyntaxVisitor
-	redef meth visit(n) do n.accept_class_specialization_builder(self)
+	redef fun visit(n) do n.accept_class_specialization_builder(self)
 	init(tc, m) do super
 end
 
@@ -288,7 +337,7 @@ end
 # * Compute types in ancestors
 private class ClassAncestorBuilder
 special AbsSyntaxVisitor
-	redef meth visit(n) do n.accept_class_ancestor_builder(self)
+	redef fun visit(n) do n.accept_class_ancestor_builder(self)
 	init(tc, m) do super
 end
 
@@ -296,7 +345,7 @@ end
 # * Checks classes in regard to superclasses
 private class ClassVerifierVisitor
 special AbsSyntaxVisitor
-	redef meth visit(n) do n.accept_class_verifier(self)
+	redef fun visit(n) do n.accept_class_verifier(self)
 	init(tc, m) do super
 end
 
@@ -307,7 +356,7 @@ end
 # * Attach bound to formal types
 private class PropertyBuilderVisitor
 special AbsSyntaxVisitor
-	redef meth visit(n) do n.accept_property_builder(self)
+	redef fun visit(n) do n.accept_property_builder(self)
 	init(tc, m) do super
 end
 
@@ -315,42 +364,56 @@ end
 # * Check property conformance
 private class PropertyVerifierVisitor
 special AbsSyntaxVisitor
+
+	# The signature currently build
+	readable writable var _signature_builder: SignatureBuilder
+
+	redef fun visit(n) do n.accept_property_verifier(self)
+
+	init(tc, m)
+	do
+		super
+		_signature_builder = new SignatureBuilder
+	end
+end
+
+# Information about a signature currently build
+private class SignatureBuilder
 	# Current visited parameter types
-	readable writable attr _params: Array[PParam] 
+	readable writable var _params: Array[PParam] = new Array[PParam]
 	
 	# Visited parameters without type information added
-	readable writable attr _untyped_params: Array[PParam]
+	readable writable var _untyped_params: Array[PParam] = new Array[PParam]
 
 	# Position of the current star parameter
-	readable writable attr _vararg_rank: Int
+	readable writable var _vararg_rank: Int = -1
 
-	# Current signature
-	readable writable attr _signature: MMSignature 
+	# Current closure declarations
+	readable writable var _closure_decls: Array[AClosureDecl] = new Array[AClosureDecl]
 
-	redef meth visit(n) do n.accept_property_verifier(self)
-
-	init(tc, m) do super
+	# Current signature
+	readable writable var _signature: nullable MMSignature = null 
 end
 
 ###############################################################################
 
 redef class PNode
-	private meth accept_class_builder(v: ClassBuilderVisitor) do accept_abs_syntax_visitor(v)
-	private meth accept_class_specialization_builder(v: ClassSpecializationBuilderVisitor) do accept_abs_syntax_visitor(v)
-	private meth accept_class_ancestor_builder(v: ClassAncestorBuilder) do accept_abs_syntax_visitor(v)
-	private meth accept_class_verifier(v: ClassVerifierVisitor) do accept_abs_syntax_visitor(v)
-	private meth accept_property_builder(v: PropertyBuilderVisitor) do accept_abs_syntax_visitor(v)
-	private meth accept_property_verifier(v: PropertyVerifierVisitor) do accept_abs_syntax_visitor(v)
+	private fun accept_class_builder(v: ClassBuilderVisitor) do accept_abs_syntax_visitor(v)
+	private fun accept_class_specialization_builder(v: ClassSpecializationBuilderVisitor) do accept_abs_syntax_visitor(v)
+	private fun accept_class_ancestor_builder(v: ClassAncestorBuilder) do accept_abs_syntax_visitor(v)
+	private fun accept_class_verifier(v: ClassVerifierVisitor) do accept_abs_syntax_visitor(v)
+	private fun accept_property_builder(v: PropertyBuilderVisitor) do accept_abs_syntax_visitor(v)
+	private fun accept_property_verifier(v: PropertyVerifierVisitor) do accept_abs_syntax_visitor(v)
 end
 
 redef class AModule
 	# Import supermodules and compute visibility
-	meth import_super_modules(tc: ToolContext, mod: MMSrcModule)
+	fun import_super_modules(tc: ToolContext, mod: MMSrcModule)
 	do
 		# Import super-modules
 		var module_names_to_import = new Array[Symbol]
 		var module_visibility = new HashMap[Symbol, Int]
-		var no_import: PImport = null
+		var no_import: nullable PImport = null
 		for i in n_imports do
 			var n = i.module_name
 			if n != null then
@@ -381,7 +444,7 @@ redef class AModule
 end
 
 redef class APackagedecl
-	redef meth accept_class_builder(v)
+	redef fun accept_class_builder(v)
 	do
 		if n_id.to_symbol != v.module.name then
 			v.error(n_id, "Error: Package name missmatch between {v.module.name} and {n_id.to_symbol}")
@@ -391,23 +454,23 @@ end
 
 redef class PImport
 	# Imported module name (or null)
-	meth module_name: Symbol is abstract
+	fun module_name: nullable Symbol is abstract
 
 	# Visibility level (intrude/public/private)
-	meth visibility_level: Int is abstract
+	fun visibility_level: Int is abstract
 end
 redef class AImport
-	redef meth module_name
+	redef fun module_name
 	do
 		return n_id.to_symbol
 	end
-	redef meth visibility_level
+	redef fun visibility_level
 	do
 		return n_visibility.level
 	end
 end
 redef class ANoImport
-	redef meth module_name
+	redef fun module_name
 	do
 		return null
 	end
@@ -415,35 +478,36 @@ end
 
 redef class PVisibility
 	# Visibility level
-	meth level: Int is abstract
+	fun level: Int is abstract
 end
 redef class APublicVisibility
-	redef meth level do return 1
+	redef fun level do return 1
 end
 redef class AProtectedVisibility
-	redef meth level do return 2
+	redef fun level do return 2
 end
 redef class APrivateVisibility
-	redef meth level do return 3
+	redef fun level do return 3
 end
 redef class AIntrudeVisibility
-	redef meth level do return 0
+	redef fun level do return 0
 end
 
 
 redef class PClassdef
-	redef readable attr _local_class: MMSrcLocalClass
+	redef fun local_class: MMSrcLocalClass do return _local_class.as(not null)
+	var _local_class: nullable MMSrcLocalClass
 
 	# Name of the class
-	meth name: Symbol is abstract
+	fun name: Symbol is abstract
 
 	# Number of formal parameters
-	meth arity: Int do return 0
+	fun arity: Int do return 0
 
 	# Visibility of the class
-	meth visibility_level: Int do return 1
+	fun visibility_level: Int do return 1
 
-	redef meth accept_class_builder(v)
+	redef fun accept_class_builder(v)
 	do
 		var local_class: MMSrcLocalClass
 		var mod = v.module
@@ -457,32 +521,27 @@ redef class PClassdef
 			end
 			local_class.nodes.add(self)
 		else
-			local_class = new MMSrcLocalClass(name, self, arity)
-			mod.add_local_class(local_class)
+			local_class = new MMSrcLocalClass(mod, name, self, arity)
 			local_classes[name] = local_class
-			var g = mod.global_class_named(name)
-			if g == null then
-				# Intro
+			if not mod.has_global_class_named(name) then
 				local_class.new_global
-				g = local_class.global
 			else
-				local_class.set_global(g)
+				local_class.set_global(mod.global_class_named(name))
 			end
 
 		end
 		_local_class = local_class
 		v.local_class_arity = 0
-		v.formals = new HashMap[Symbol, MMTypeFormalParameter]
+		v.formals = local_class.formal_dict
 
 		#####
 		super
 		#####
 
-		_local_class.formal_dict = v.formals
 		v.formals = null
 	end
 
-	redef meth accept_abs_syntax_visitor(v)
+	redef fun accept_abs_syntax_visitor(v)
 	do
 		v.local_class = _local_class
 		super
@@ -491,31 +550,31 @@ redef class PClassdef
 end
 
 redef class PClasskind
-	meth is_interface: Bool do return false
-	meth is_universal: Bool do return false
-	meth is_abstract: Bool do return false
+	fun is_interface: Bool do return false
+	fun is_universal: Bool do return false
+	fun is_abstract: Bool do return false
 end
 
 redef class AInterfaceClasskind
-	redef meth is_interface do return true
+	redef fun is_interface do return true
 end
 redef class AUniversalClasskind
-	redef meth is_universal do return true
+	redef fun is_universal do return true
 end
 redef class AAbstractClasskind
-	redef meth is_abstract do return true
+	redef fun is_abstract do return true
 end
 
 redef class AClassdef
-	redef meth name
+	redef fun name
 	do
 		return n_id.to_symbol
 	end
-	redef meth arity
+	redef fun arity
 	do
 		return n_formaldefs.length
 	end
-	redef meth accept_class_verifier(v)
+	redef fun accept_class_verifier(v)
 	do
 		super
 		var glob = _local_class.global
@@ -572,21 +631,21 @@ redef class AClassdef
 		end
 	end
 
-	redef meth visibility_level
+	redef fun visibility_level
 	do
 		return n_visibility.level
 	end
 end
 
 redef class AMainClassdef
-	redef meth name
+	redef fun name
 	do
 		return once "Sys".to_symbol
 	end
 end
 
 redef class ATopClassdef
-	redef meth name
+	redef fun name
 	do
 		return once "Object".to_symbol
 	end
@@ -595,7 +654,7 @@ end
 class MMSrcTypeFormalParameter
 special MMTypeFormalParameter
 	# The associated node
-	readable attr _node: AFormaldef 
+	readable var _node: AFormaldef 
 
 	init(name: Symbol, pos: Int, local_class: MMLocalClass, n: AFormaldef)
 	do
@@ -606,9 +665,9 @@ end
 
 redef class AFormaldef
 	# The associated formal generic parameter (MM entity)
-	attr _formal: MMSrcTypeFormalParameter
+	var _formal: nullable MMSrcTypeFormalParameter
 
-	redef meth accept_class_builder(v)
+	redef fun accept_class_builder(v)
 	do
 		var name = n_id.to_symbol
 		var formal_type = new MMSrcTypeFormalParameter(name, v.local_class_arity, v.local_class, self)
@@ -619,23 +678,23 @@ redef class AFormaldef
 		super
 	end
 
-	redef meth accept_class_verifier(v)
+	redef fun accept_class_verifier(v)
 	do
 		super
 		var c = v.local_class
 		var o = c.global.intro
 		if c == o then
 			if n_type == null then
-				_formal.bound = v.module.type_any
+				_formal.bound = v.module.type_any.as_nullable
 			else
-				_formal.bound = n_type.get_stype(v)
+				_formal.bound = n_type.get_stype(v).as(not null)
 			end
 		else
 			var ob = o.get_formal(_formal.position).bound.for_module(v.module)
 			if n_type == null then
 				_formal.bound = ob
 			else
-				_formal.bound = n_type.get_stype(v)
+				_formal.bound = n_type.get_stype(v).as(not null)
 				if _formal.bound != ob then
 					v.error(self, "Redef error: Cannot change formal parameter type of class {c}; got {_formal.bound}, expected {ob}.")
 				end
@@ -645,25 +704,26 @@ redef class AFormaldef
 end
 
 redef class ASuperclass
-	readable attr _ancestor: MMSrcAncestor
+	readable var _ancestor: nullable MMSrcAncestor
 
-	redef meth accept_class_specialization_builder(v)
+	redef fun accept_class_specialization_builder(v)
 	do
 		super
 		var c = n_type.get_local_class(v)
+		if c == null then return
 		var ancestor = new MMSrcAncestor(self, c)
 		_ancestor = ancestor
 		v.local_class.add_direct_parent(ancestor)
 	end
 
-	redef meth accept_class_ancestor_builder(v)
+	redef fun accept_class_ancestor_builder(v)
 	do
 		super
 		_ancestor.stype = n_type.get_unchecked_stype(v)
 		_ancestor.inheriter = v.local_class.get_type
 	end
 
-	redef meth accept_class_verifier(v)
+	redef fun accept_class_verifier(v)
 	do
 		super
 		n_type.check_conform(v)
@@ -677,7 +737,7 @@ redef class PPropdef
 	# * Check redef errors.
 	# * Check forbiden attribute definitions.
 	# * Check signature conformance.
-	private meth process_and_check(v: PropertyVerifierVisitor, prop: MMLocalProperty, has_redef: Bool, visibility_level: Int)
+	private fun process_and_check(v: PropertyVerifierVisitor, prop: MMLocalProperty, has_redef: Bool, visibility_level: Int)
 	do
 		if prop.global.intro == prop then
 			do_and_check_intro(v, prop, has_redef, visibility_level)
@@ -687,7 +747,7 @@ redef class PPropdef
 	end
 
 	# The part of process_and_check when prop is an introduction
-	private meth do_and_check_intro(v: PropertyVerifierVisitor, prop: MMLocalProperty, has_redef: Bool, visibility_level: Int)
+	private fun do_and_check_intro(v: PropertyVerifierVisitor, prop: MMLocalProperty, has_redef: Bool, visibility_level: Int)
 	do
 		var glob = prop.global
 		var gbc = prop.local_class.global
@@ -719,26 +779,29 @@ redef class PPropdef
 			end
 			if prop.signature != null then
 				# ok
-			else if not v.untyped_params.is_empty then
-				v.error(v.untyped_params.first, "Error: Untyped parameter.")
+			else if not v.signature_builder.untyped_params.is_empty then
+				v.error(v.signature_builder.untyped_params.first, "Error: Untyped parameter.")
 			else
 				prop.signature = new MMSignature(new Array[MMType], null, v.local_class.get_type)
+				for clos in v.signature_builder.closure_decls do
+					prop.signature.closures.add(clos.variable.closure)
+				end
 			end
 		end
 	end
 
-	private meth inherit_signature(v: PropertyVerifierVisitor, prop: MMLocalProperty, supers: Array[MMLocalProperty])
+	private fun inherit_signature(v: PropertyVerifierVisitor, prop: MMLocalProperty, supers: Array[MMLocalProperty])
 	do
 		var s = prop.signature
 		for ip in supers do
 			var isig = ip.signature.adaptation_to(v.local_class.get_type)
 
 			if s == null then
-				if v.params.length != isig.arity then
+				if v.signature_builder.params.length != isig.arity then
 					#prop.node.printl("v.params.length {v.params.length} != isig.arity {isig.arity} ; {prop.full_name} vs {ip.full_name}")
 					return
 				end
-				for p in v.params do
+				for p in v.signature_builder.params do
 					var t = isig[p.position]
 					p.stype = t
 					if p.position == isig.vararg_rank then
@@ -754,7 +817,7 @@ redef class PPropdef
 	end
 
 	# The part of process_and_check when prop is a redefinition
-	private meth do_and_check_redef(v: PropertyVerifierVisitor, prop: MMLocalProperty, has_redef: Bool, visibility_level: Int)
+	private fun do_and_check_redef(v: PropertyVerifierVisitor, prop: MMLocalProperty, has_redef: Bool, visibility_level: Int)
 	do
 		var is_init = self isa AConcreteInitPropdef
 		var glob = prop.global
@@ -777,11 +840,15 @@ redef class PPropdef
 
 			if s == null then
 				#print "{prop.full_name} inherits signature from {ip.full_name}"
-				if v.params.length != isig.arity then
+				if v.signature_builder.params.length != isig.arity then
 					v.error(self, "Redef error: {prop.local_class}::{prop} redefines {ip.local_class}::{ip} with {isig.arity} parameter(s).")
 					return
 				end
-				for p in v.params do
+				if v.signature_builder.closure_decls.length != isig.closures.length then
+					v.error(self, "Redef error: {prop.local_class}::{prop} redefines {ip.local_class}::{ip} with {isig.arity} closure(s).")
+					return
+				end
+				for p in v.signature_builder.params do
 					var t = isig[p.position]
 					p.stype = t
 					if p.position == isig.vararg_rank then
@@ -791,15 +858,18 @@ redef class PPropdef
 				end
 				s = isig
 				prop.signature = s
+				#print "s is null"
 			end
 
+			var nberr = v.tc.error_count
+			#print "Check {prop.local_class}::{prop}{s} vs {ip.local_class}::{ip}{isig}"
+			#print "s={s.object_id} isig={isig.object_id} isigorig={i.signature.object_id}"
+
 			#print "orig signature:  {i.signature.recv} . {i.signature}"
 			#print "inh signature:   {isig.recv} . {isig}"
 			#print "redef signature: {s.recv} . {s}"
 
-			if glob.is_init and i.local_class.global != prop.local_class.global then
-				# Do not check signature
-			else if s.arity != isig.arity then
+			if s.arity != isig.arity then
 				v.error(self, "Redef error: {prop.local_class}::{prop} redefines {ip.local_class}::{ip} with {isig.arity} parameter(s).")
 			else
 				for i in [0..s.arity[ do
@@ -817,6 +887,9 @@ redef class PPropdef
 				v.error(self, "Redef error: The function {prop.local_class}::{prop} redefines the procedure {ip.local_class}::{ip}.")
 			else if srt != null and isrt != null and not srt < isrt then
 				v.error(self, "Redef error: Expected {isrt} (as in {ip.local_class}::{ip}), got {srt} in {prop.local_class}::{prop}.")
+			else if not s < isig and nberr == v.tc.error_count then
+				# Systematic fallback for conformance check
+				v.error(self, "Redef error: Incompatible redefinition of {ip.local_class}::{ip} with {prop.local_class}::{prop}")
 			else if srt != null and isrt != null and srt != isrt and prop isa MMAttribute then
 				# FIXME: To remove
 				v.warning(self, "Redef warning: Expected {isrt} (as in {ip.local_class}::{ip}), got {srt} in {prop.local_class}::{prop}.")
@@ -831,60 +904,68 @@ redef class PPropdef
 end
 
 redef class AAttrPropdef
-	redef readable attr _readmethod: MMSrcMethod
-	redef readable attr _writemethod: MMSrcMethod
-	redef readable attr _prop: MMSrcAttribute 
+	redef readable var _readmethod: nullable MMSrcMethod
+	redef readable var _writemethod: nullable MMSrcMethod
+	var _prop: nullable MMSrcAttribute
+	redef fun prop do return _prop.as(not null)
 
-	redef meth accept_property_builder(v)
+	redef fun accept_property_builder(v)
 	do
 		super
 		var name = n_id.to_symbol
-		var prop = new MMSrcAttribute(name, v.local_class, self)
+		var lc = v.local_class
+		var prop = new MMSrcAttribute(name, lc, self)
 		_prop = prop
 		v.local_class.add_src_local_property(v, prop)
 
 		if n_readable != null then
 			name = n_id.text.substring_from(1).to_symbol
-			_readmethod = new MMReadImplementationMethod(name, v.local_class, self)
-			v.local_class.add_src_local_property(v, _readmethod)
+			var readmethod = new MMReadImplementationMethod(name, lc, self)
+			_readmethod = readmethod
+			v.local_class.add_src_local_property(v, readmethod)
 		end
 		if n_writable != null then
 			name = (n_id.text.substring_from(1) + "=").to_symbol
-			_writemethod = new MMWriteImplementationMethod(name, v.local_class, self)
-			v.local_class.add_src_local_property(v, _writemethod)
+			var writemethod = new MMWriteImplementationMethod(name, lc, self)
+			_writemethod = writemethod
+			v.local_class.add_src_local_property(v, writemethod)
 		end
 	end
 	
-	redef meth accept_property_verifier(v)
+	redef fun accept_property_verifier(v)
 	do
 		super
 		var t: MMType
 		if n_type != null then
-			t = n_type.get_stype(v)
+			var t0 = n_type.get_stype(v)
+			if t0 != null then t = t0 else return
 		else
 			v.error(self, "Not yet implemented: Attribute definition {_prop.local_class}::{_prop} requires an explicit type.")
 			return
 		end
 
+		var prop = prop
 		var signature = new MMSignature(new Array[MMType], t, v.local_class.get_type)
-		_prop.signature = signature
+		prop.signature = signature
 		var visibility_level = n_visibility.level
-		process_and_check(v, _prop, n_kwredef != null, visibility_level)
+		process_and_check(v, prop, n_kwredef != null, visibility_level)
 		if n_readable != null then
-			_readmethod.signature = signature
-			process_and_check(v, _readmethod, n_readable.n_kwredef != null, visibility_level)
-			n_type.check_visibility(v, _readmethod)
+			var m = _readmethod.as(not null)
+			m.signature = signature
+			process_and_check(v, m, n_readable.n_kwredef != null, visibility_level)
+			n_type.check_visibility(v, m)
 		end
 		if n_writable != null then
-			_writemethod.signature = new MMSignature(new Array[MMType].with(t), null, v.local_class.get_type)
-			process_and_check(v, _writemethod, n_writable.n_kwredef != null, visibility_level)
-			n_type.check_visibility(v, _writemethod)
+			var m = _writemethod.as(not null)
+			m.signature = new MMSignature(new Array[MMType].with_items(t), null, v.local_class.get_type)
+			process_and_check(v, m, n_writable.n_kwredef != null, visibility_level)
+			n_type.check_visibility(v, m)
 		end
 	end
 
-	redef meth accept_abs_syntax_visitor(v)
+	redef fun accept_abs_syntax_visitor(v)
 	do
-		v.local_property = prop
+		v.local_property = _prop
 		super
 		v.local_property = null
 	end
@@ -892,66 +973,65 @@ end
 
 redef class AMethPropdef
 	# Name of the method
-	readable attr _name: Symbol 
+	readable var _name: nullable Symbol 
 
-	redef readable attr _method: MMMethSrcMethod
+	var _method: nullable MMMethSrcMethod
+	redef fun method do return _method.as(not null)
 
-	redef meth accept_property_builder(v)
+	redef fun accept_property_builder(v)
 	do
 		super
+		var name: Symbol
 		if n_methid == null then
 			if self isa AConcreteInitPropdef then
-				_name = once "init".to_symbol
+				name = once "init".to_symbol
 			else
-				_name = once "main".to_symbol
+				name = once "main".to_symbol
 			end
-		else 
-			_name = n_methid.name
+		else
+			name = n_methid.name.as(not null)
 			# FIXME: Add the 'unary' keyword
 			if n_methid.name == (once "-".to_symbol) then
 				var ns = n_signature
 				if ns isa ASignature and ns.n_params.length == 0 then
-					_name = once "unary -".to_symbol
+					name = once "unary -".to_symbol
 				end
 			end
 		end
-		var prop = new MMMethSrcMethod(_name, v.local_class, self)
+		_name = name
+		var prop = new MMMethSrcMethod(name, v.local_class, self)
 		_method = prop
 		v.local_class.add_src_local_property(v, prop)
 	end
 
-	redef meth accept_property_verifier(v)
+	redef fun accept_property_verifier(v)
 	do
-		v.params = new Array[PParam]
-		v.untyped_params = new Array[PParam]
-		v.signature = null
-		v.vararg_rank = -1
-
+		v.signature_builder = new SignatureBuilder
 		super
 
-		if v.signature == null then
+		if v.signature_builder.signature == null then
 			#_method.signature = new MMSignature(new Array[MMType], null, v.local_class.get_type)
 		else
-			_method.signature = v.signature
+			method.signature = v.signature_builder.signature.as(not null)
 		end
 		var visibility_level = 1
 		if n_visibility != null and n_visibility.level > 1 then
 			visibility_level = n_visibility.level
 		end
-		process_and_check(v, _method, n_kwredef != null, visibility_level)
-		if n_signature != null then n_signature.check_visibility(v, _method)
+		process_and_check(v, method, n_kwredef != null, visibility_level)
+		if n_signature != null then n_signature.check_visibility(v, method)
 	end
 
-	redef meth accept_abs_syntax_visitor(v)
+	redef fun accept_abs_syntax_visitor(v)
 	do
-		v.local_property = method
+		v.local_property = _method
 		super
 		v.local_property = null
 	end
 end
 
 redef class AMainMethPropdef
-	redef meth process_and_check(v, prop, has_redef, visibility_level)
+	redef fun process_and_check(v, prop, has_redef, visibility_level)
 	do
 		prop.global.visibility_level = visibility_level
 		prop.signature = new MMSignature(new Array[MMType], null, v.local_class.get_type)
@@ -960,9 +1040,10 @@ redef class AMainMethPropdef
 end
 
 redef class ATypePropdef
-	redef readable attr _prop: MMSrcTypeProperty 
+	redef fun prop do return _prop.as(not null)
+	var _prop: nullable MMSrcTypeProperty
 
-	redef meth accept_property_builder(v)
+	redef fun accept_property_builder(v)
 	do
 		super
 		var name = n_id.to_symbol
@@ -971,18 +1052,18 @@ redef class ATypePropdef
 		v.local_class.add_src_local_property(v, prop)
 	end
 	
-	redef meth accept_property_verifier(v)
+	redef fun accept_property_verifier(v)
 	do
 		super
 		var signature = new MMSignature(new Array[MMType], n_type.get_stype(v), v.local_class.get_type)
-		_prop.signature = signature
+		prop.signature = signature
 		var visibility_level = n_visibility.level
-		process_and_check(v, _prop, n_kwredef != null, visibility_level)
+		process_and_check(v, prop, n_kwredef != null, visibility_level)
 	end
 	
-	redef meth accept_abs_syntax_visitor(v)
+	redef fun accept_abs_syntax_visitor(v)
 	do
-		v.local_property = prop
+		v.local_property = _prop
 		super
 		v.local_property = null
 	end
@@ -991,8 +1072,8 @@ end
 # Visitor used to build a full method name from multiple tokens
 private class MethidAccumulator
 special Visitor
-	readable attr _name: String 
-	redef meth visit(n)
+	readable var _name: Buffer = new Buffer
+	redef fun visit(n)
 	do
 		if n isa Token then
 			_name.append(n.text)
@@ -1000,57 +1081,55 @@ special Visitor
 			n.visit_all(self)
 		end
 	end
-
-	init
-	do
-		_name = new String
-	end
 end
 
 redef class PMethid
 	# Method name
-	readable attr _name: Symbol 
+	readable var _name: nullable Symbol 
 
-	redef meth accept_property_builder(v)
+	redef fun accept_property_builder(v)
 	do
 		var accumulator = new MethidAccumulator
 		accumulator.visit(self)
-		_name = accumulator.name.to_symbol
+		_name = accumulator.name.to_s.to_symbol
 		super
 	end
 end
 
 redef class PSignature
 	# Check that visibilities of types in the signature are compatible with the visibility of the property.
-	meth check_visibility(v: AbsSyntaxVisitor, p: MMLocalProperty) is abstract
+	fun check_visibility(v: AbsSyntaxVisitor, p: MMLocalProperty) is abstract
 end
 
 redef class ASignature
-	redef meth accept_property_verifier(v)
+	redef fun accept_property_verifier(v)
 	do
 		super
-		if not v.untyped_params.is_empty then
-			if v.untyped_params.first != v.params.first or n_type != null then
-				v.error(v.untyped_params.first, "Syntax error: untyped parameter.")
+		if not v.signature_builder.untyped_params.is_empty then
+			if v.signature_builder.untyped_params.first != v.signature_builder.params.first or n_type != null then
+				v.error(v.signature_builder.untyped_params.first, "Syntax error: untyped parameter.")
 				return
 			end
-		else if not v.params.is_empty or n_type != null then
+		else if not v.signature_builder.params.is_empty or n_type != null then
 			var pars = new Array[MMType]
-			for p in v.params do
-				pars.add(p.stype)
+			for p in v.signature_builder.params do
+				pars.add(p.stype.as(not null))
 			end
-			var ret: MMType = null
+			var ret: nullable MMType = null
 			if n_type != null then
 				ret = n_type.get_stype(v)
 			end
-			v.signature = new MMSignature(pars, ret, v.local_class.get_type)
-			if v.vararg_rank >= 0 then
-				v.signature.vararg_rank = v.vararg_rank
+			v.signature_builder.signature = new MMSignature(pars, ret, v.local_class.get_type)
+			if v.signature_builder.vararg_rank >= 0 then
+				v.signature_builder.signature.vararg_rank = v.signature_builder.vararg_rank
+			end
+			for clos in v.signature_builder.closure_decls do
+				v.signature_builder.signature.closures.add(clos.variable.closure)
 			end
 		end
 	end
 
-	redef meth check_visibility(v, p)
+	redef fun check_visibility(v, p)
 	do
 		if p.global.visibility_level >= 3 then return
 		for n in n_params do
@@ -1061,58 +1140,87 @@ redef class ASignature
 end
 
 redef class PParam
-	redef readable attr _position: Int
+	redef readable var _position: Int = 0
 
-	redef readable attr _variable: Variable 
+	redef fun variable: ParamVariable do return _variable.as(not null)
+	var _variable: nullable ParamVariable
 
 	# The type of the parameter in signature
-	readable writable attr _stype: MMType
+	readable writable var _stype: nullable MMType
 
-	redef meth accept_property_verifier(v)
+	redef fun accept_property_verifier(v)
 	do
 		super
-		_position = v.params.length
-		_variable = new Variable(n_id.to_symbol, self)
-		v.params.add(self)
-		v.untyped_params.add(self)
+		_position = v.signature_builder.params.length
+		_variable = new ParamVariable(n_id.to_symbol, self)
+		v.signature_builder.params.add(self)
+		v.signature_builder.untyped_params.add(self)
 		if n_type != null then
-			var stype = n_type.get_stype(v)
-			for p in v.untyped_params do
+			var stype = n_type.get_stype(v).as(not null)
+			for p in v.signature_builder.untyped_params do
 				p.stype = stype
 				if is_vararg then
-					if v.vararg_rank == -1 then
-						v.vararg_rank = p.position
+					if v.signature_builder.vararg_rank == -1 then
+						v.signature_builder.vararg_rank = p.position
 					else
 						v.error(self, "Error: A vararg parameter is already defined.")
 					end
-					stype = v.type_array(stype) 
+					stype = v.type_array(stype)
 				end
 				p.variable.stype = stype
 			end
-			v.untyped_params.clear
+			v.signature_builder.untyped_params.clear
 		end
 	end
 
-	meth is_vararg: Bool is abstract
+	fun is_vararg: Bool is abstract
 end
 
 redef class AParam
-	redef meth is_vararg do return n_dotdotdot != null
+	redef fun is_vararg do return n_dotdotdot != null
+end
+
+redef class AClosureDecl
+	redef fun variable: ClosureVariable do return _variable.as(not null)
+	var _variable: nullable ClosureVariable
+
+	redef fun accept_property_verifier(v)
+	do
+		var old_signature_builder = v.signature_builder
+		v.signature_builder = new SignatureBuilder
+		super
+		var sig = v.signature_builder.signature
+		if sig == null then
+			sig = new MMSignature(new Array[MMType], null, v.local_class.get_type)
+		end
+		if sig.return_type != null and n_kwbreak != null then
+			v.error(self, "Syntax Error: A break block cannot have a return value.")
+		end
+
+		# Add the finalizer to the closure signature
+		var finalize_sig = new MMSignature(new Array[MMType], null, v.module.type_any) # FIXME should be no receiver
+		var finalizer_clos = new MMClosure(finalize_sig, false, true)
+		sig.closures.add(finalizer_clos)
+
+		var clos = new MMClosure(sig, n_kwbreak != null, n_expr != null)
+		v.signature_builder = old_signature_builder
+		old_signature_builder.closure_decls.add(self)
+		_variable = new ClosureVariable(n_id.to_symbol, self, clos)
+	end
 end
 
 redef class PType
 	# Check that visibilities of types in the signature are compatible with the visibility of the property.
-	private meth check_visibility(v: AbsSyntaxVisitor, p: MMLocalProperty) is abstract
+	private fun check_visibility(v: AbsSyntaxVisitor, p: MMLocalProperty) is abstract
 end
 
 redef class AType
-	redef meth check_visibility(v, p)
+	redef fun check_visibility(v, p)
 	do
 		if p.global.visibility_level >= 3 then return
 		var t = get_stype(v)
 		if t == null then return
 		var bc = t.local_class
-		if bc == null then return
 		if bc.global.visibility_level >= 3 then
 			v.error(self, "Access error: Class {bc} is private and cannot be used in the signature of the non-private property {p}.")
 		end
@@ -1123,7 +1231,7 @@ redef class AType
 end
 
 redef class PExpr
-	redef meth accept_class_builder(v) do end
-	redef meth accept_property_builder(v) do end
-	redef meth accept_property_verifier(v) do end
+	redef fun accept_class_builder(v) do end
+	redef fun accept_property_builder(v) do end
+	redef fun accept_property_verifier(v) do end
 end