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

diff --git a/src/syntax/mmbuilder.nit b/src/syntax/mmbuilder.nit
index ccdd2a6..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)
@@ -154,7 +154,7 @@ redef class MMSrcLocalClass
 	end
 
 	# 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
@@ -173,8 +173,9 @@ redef class MMSrcLocalClass
 				if not gp.is_init then continue
 				super_constructors.add(gp)
 			end
-			var gp = sc.get_property_by_name(once ("init".to_symbol))
-			if gp != null then
+			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
@@ -184,7 +185,6 @@ redef class MMSrcLocalClass
 		for a in src_local_properties do
 			if a isa MMSrcAttribute then
 				var n = a.node
-				assert n isa AAttrPropdef
 				if n.n_expr == null then unassigned_attributes.add(a)
 			end
 		end
@@ -203,7 +203,7 @@ redef class MMSrcLocalClass
 			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(", ")}.")
@@ -218,7 +218,7 @@ redef class MMSrcLocalClass
 					make_visible_an_inherited_global_property(gp)
 				end
 			end
-			global.mixin_of = superclass.global
+			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}.")
 
@@ -231,7 +231,7 @@ redef class MMSrcLocalClass
 
 	# 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
@@ -243,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
@@ -259,16 +255,16 @@ 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 attr _super_init: MMLocalProperty = null
-	redef meth accept_property_visitor(v)
+	readable var _super_init: nullable MMLocalProperty = null
+	redef fun accept_property_visitor(v)
 	do
-		var base: MMLocalProperty = null
+		var base: nullable MMLocalProperty = null
 		for p in super_inits do
 			if p.signature.arity > 0 then
 				if base == null then
@@ -289,7 +285,9 @@ redef class MMImplicitInit
 			end
 		end
 		for a in unassigned_attributes do
-			params.add(a.signature.return_type)
+			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
@@ -300,8 +298,8 @@ end
 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
@@ -318,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
 
@@ -331,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
 
@@ -339,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
 
@@ -347,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
 
@@ -358,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
 
@@ -368,9 +366,9 @@ private class PropertyVerifierVisitor
 special AbsSyntaxVisitor
 
 	# The signature currently build
-	readable writable attr _signature_builder: SignatureBuilder
+	readable writable var _signature_builder: SignatureBuilder
 
-	redef meth visit(n) do n.accept_property_verifier(self)
+	redef fun visit(n) do n.accept_property_verifier(self)
 
 	init(tc, m)
 	do
@@ -382,40 +380,40 @@ end
 # Information about a signature currently build
 private class SignatureBuilder
 	# Current visited parameter types
-	readable writable attr _params: Array[PParam] = new Array[PParam]
+	readable writable var _params: Array[PParam] = new Array[PParam]
 	
 	# Visited parameters without type information added
-	readable writable attr _untyped_params: Array[PParam] = new Array[PParam]
+	readable writable var _untyped_params: Array[PParam] = new Array[PParam]
 
 	# Position of the current star parameter
-	readable writable attr _vararg_rank: Int = -1
+	readable writable var _vararg_rank: Int = -1
 
 	# Current closure declarations
-	readable writable attr _closure_decls: Array[AClosureDecl] = new Array[AClosureDecl]
+	readable writable var _closure_decls: Array[AClosureDecl] = new Array[AClosureDecl]
 
 	# Current signature
-	readable writable attr _signature: MMSignature = null 
+	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
@@ -446,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}")
@@ -456,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
@@ -480,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
@@ -522,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
@@ -556,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
@@ -637,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
@@ -660,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
@@ -671,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)
@@ -684,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
@@ -710,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)
@@ -742,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)
@@ -752,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
@@ -788,16 +783,14 @@ redef class PPropdef
 				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)
-				if v.signature_builder.closure_decls != null then
-					for clos in v.signature_builder.closure_decls do
-						prop.signature.closures.add(clos.variable.closure)
-					end
+				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
@@ -824,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
@@ -851,6 +844,10 @@ redef class PPropdef
 					v.error(self, "Redef error: {prop.local_class}::{prop} redefines {ip.local_class}::{ip} with {isig.arity} parameter(s).")
 					return
 				end
+				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
@@ -907,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_items(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
@@ -968,35 +973,38 @@ 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.signature_builder = new SignatureBuilder
 		super
@@ -1004,26 +1012,26 @@ redef class AMethPropdef
 		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_builder.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)
@@ -1032,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
@@ -1043,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
@@ -1063,8 +1072,8 @@ end
 # Visitor used to build a full method name from multiple tokens
 private class MethidAccumulator
 special Visitor
-	readable attr _name: Buffer = new Buffer
-	redef meth visit(n)
+	readable var _name: Buffer = new Buffer
+	redef fun visit(n)
 	do
 		if n isa Token then
 			_name.append(n.text)
@@ -1076,9 +1085,9 @@ 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)
@@ -1089,11 +1098,11 @@ 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.signature_builder.untyped_params.is_empty then
@@ -1104,9 +1113,9 @@ redef class ASignature
 		else if not v.signature_builder.params.is_empty or n_type != null then
 			var pars = new Array[MMType]
 			for p in v.signature_builder.params do
-				pars.add(p.stype)
+				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
@@ -1120,7 +1129,7 @@ redef class ASignature
 		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
@@ -1131,14 +1140,15 @@ redef class ASignature
 end
 
 redef class PParam
-	redef readable attr _position: Int
+	redef readable var _position: Int = 0
 
-	redef readable attr _variable: ParamVariable 
+	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.signature_builder.params.length
@@ -1146,7 +1156,7 @@ redef class PParam
 		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)
+			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
@@ -1155,7 +1165,7 @@ redef class PParam
 					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
@@ -1163,17 +1173,18 @@ redef class PParam
 		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 readable attr _variable: ClosureVariable
+	redef fun variable: ClosureVariable do return _variable.as(not null)
+	var _variable: nullable ClosureVariable
 
-	redef meth accept_property_verifier(v)
+	redef fun accept_property_verifier(v)
 	do
 		var old_signature_builder = v.signature_builder
 		v.signature_builder = new SignatureBuilder
@@ -1183,11 +1194,11 @@ redef class AClosureDecl
 			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 bloc cannot have a return value.")
+			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, null)
+		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)
 
@@ -1200,17 +1211,16 @@ 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
@@ -1221,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