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

diff --git a/src/syntax/mmbuilder.nit b/src/syntax/mmbuilder.nit
index cdcf45e..3534938 100644
--- a/src/syntax/mmbuilder.nit
+++ b/src/syntax/mmbuilder.nit
@@ -23,8 +23,8 @@ import syntax_base
 
 # Class specialization hierarchy sorter
 private class CSHSorter
-special AbstractSorter[MMLocalClass]
-	redef meth compare(a, b)
+	super AbstractSorter[MMLocalClass]
+	redef fun compare(a, b)
 	do
 		return a.cshe.rank <=> b.cshe.rank
 	end
@@ -35,31 +35,36 @@ 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
 
 		# Create local classes and attach them to global classes
 		var mmbv = new ClassBuilderVisitor(tc, self)
-		mmbv.visit(node)
-		if tc.error_count > 0 then exit(1)
+		mmbv.enter_visit(node)
+		tc.check_errors
+
+		if mhe.direct_greaters.is_empty then
+			process_default_classes(tc)
+		end
 
 		# Import unrefined local classes and attach them to global classes
 		import_local_classes
 
 		# Resolve classes in super clauses
 		var mmbv1 = new ClassSpecializationBuilderVisitor(tc, self)
-		mmbv1.visit(node)
-		if tc.error_count > 0 then exit(1)
+		mmbv1.enter_visit(node)
+		tc.check_errors
 
 		# Compute specialization relation
 		for c in local_classes do
-			if visibility_for(c.global.intro.module) < c.global.visibility_level then
+			if visibility_for(c.global.intro.mmmodule) < c.global.visibility_level then
 				continue
 			end
 			c.compute_super_classes
 		end
+		tc.check_errors
 
 		# Class that we will process now are those in the hierarchy
 		# Its mean all the visible classes and their super-classes
@@ -74,34 +79,31 @@ redef class MMSrcModule
 		var mmbv1b = new ClassAncestorBuilder(tc, self)
 		for c in classes do
 			c.accept_class_visitor(mmbv1b)
+			tc.check_errors
 			c.compute_ancestors
 		end
-		if tc.error_count > 0 then exit(1)
 
 		# Check class conformity
-		var mmbv1b = new ClassVerifierVisitor(tc, self)
+		var mmbv1c = new ClassVerifierVisitor(tc, self)
 		for c in classes do
-			c.accept_class_visitor(mmbv1b)
+			c.accept_class_visitor(mmbv1c)
 		end
-		if tc.error_count > 0 then exit(1)
+		tc.check_errors
 
 		# Property inhritance and introduction
 		var mmbv2 = new PropertyBuilderVisitor(tc, self)
 		for c in classes do
-			# Inherit global properties
-			c.inherit_global_properties
-
 			# Global property introduction and redefinition 
 			c.accept_class_visitor(mmbv2)
 
 			# Default and inherited constructor if needed
-			if c isa MMSrcLocalClass and c.global.intro == c and not c.global.is_universal and not c.global.is_interface then
+			if c isa MMSrcLocalClass and c.global.intro == c and not c.global.is_enum and not c.global.is_interface then
 				c.process_default_constructors(mmbv2)
 			end
 
 			# Note that inherited unredefined property are processed on demand latter
 		end
-		if tc.error_count > 0 then exit(1)
+		tc.check_errors
 
 		# Property signature analysis and inheritance conformance
 		var mmbv3 = new PropertyVerifierVisitor(tc, self)
@@ -109,43 +111,56 @@ redef class MMSrcModule
 			c.accept_properties_visitor(mmbv3)
 		end
 
-		# Check inherited local properties
-		for c in classes do
-			for g in c.global_properties do
-				if visibility_for(g.intro.module) < g.visibility_level then continue
-				var p = c[g]
-			end
-		end
+		tc.check_errors
+	end
 
-		if tc.error_count > 0 then exit(1)
+	# Create some primitive default classes if they do not exists
+	fun process_default_classes(tc: ToolContext)
+	do
+		var name = once ("Object".to_symbol)
+		if not has_global_class_named(name) then
+			var c = new MMSrcLocalClass(self, name, null, 0)
+			c.new_global
+			src_local_classes[name] = c
+		end
+		name = once ("Bool".to_symbol)
+		if not has_global_class_named(name) then
+			var c = new MMSrcLocalClass(self, name, null, 0)
+			c.new_global
+			src_local_classes[name] = c
+		end
 	end
 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)
+		var n = node
+		while n != null do
+			v.enter_visit(n)
+			n = n.next_node
 		end
 	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)
+		var n = node
+		while n != null do
+			v.enter_visit(n)
+			n = n.next_node
 		end
 
 		for p in src_local_properties do
@@ -154,7 +169,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
@@ -168,7 +183,7 @@ redef class MMSrcLocalClass
 		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
+			if sc.global.is_enum or sc.global.is_interface then continue
 			for gp in sc.global_properties do
 				if not gp.is_init then continue
 				super_constructors.add(gp)
@@ -185,7 +200,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
@@ -204,10 +218,10 @@ 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(", ")}.")
+				v.error(node, "Error: Explicit constructor required in {self} since multiple inheritance of constructor is forbiden. Conflicting classes are {supers.join(", ")}. Costructors are {super_constructors.join(", ")}.")
 				return
 			else if supers.length == 1 then
 				superclass = supers.first
@@ -219,7 +233,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}.")
 
@@ -232,7 +246,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
@@ -244,15 +258,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
@@ -260,16 +270,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)
+	redef 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
@@ -290,7 +300,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
@@ -299,14 +311,11 @@ end
 
 # Concrete NIT class specialization relation
 class MMSrcAncestor
-special MMAncestor
-	# The related AST node
-	readable attr _node: ASuperclass
-	redef readable attr _local_class: MMLocalClass
+	super MMAncestor
+	redef readable var _local_class: MMLocalClass
 
-	init(n: ASuperclass, c: MMLocalClass)
+	init(c: MMLocalClass)
 	do
-		_node = n
 		_local_class = c
 	end
 end
@@ -317,38 +326,38 @@ end
 # * Build the classes and attach them to global classes
 # * Collect generic formal parameters.
 private class ClassBuilderVisitor
-special AbsSyntaxVisitor
+	super 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
 
 # Another pass visitor for syntax analysis.
 # * 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)
+	super AbsSyntaxVisitor
+	redef fun visit(n) do n.accept_class_specialization_builder(self)
 	init(tc, m) do super
 end
 
 # Another pass visitor for syntax analysis.
 # * Compute types in ancestors
 private class ClassAncestorBuilder
-special AbsSyntaxVisitor
-	redef meth visit(n) do n.accept_class_ancestor_builder(self)
+	super AbsSyntaxVisitor
+	redef fun visit(n) do n.accept_class_ancestor_builder(self)
 	init(tc, m) do super
 end
 
 # Another pass visitor for syntax analysis.
 # * Checks classes in regard to superclasses
 private class ClassVerifierVisitor
-special AbsSyntaxVisitor
-	redef meth visit(n) do n.accept_class_verifier(self)
+	super AbsSyntaxVisitor
+	redef fun visit(n) do n.accept_class_verifier(self)
 	init(tc, m) do super
 end
 
@@ -358,20 +367,20 @@ end
 # * Build local properties and attache them to global properties
 # * Attach bound to formal types
 private class PropertyBuilderVisitor
-special AbsSyntaxVisitor
-	redef meth visit(n) do n.accept_property_builder(self)
+	super AbsSyntaxVisitor
+	redef fun visit(n) do n.accept_property_builder(self)
 	init(tc, m) do super
 end
 
 # Another pass pass visitor for syntax analysis.
 # * Check property conformance
 private class PropertyVerifierVisitor
-special AbsSyntaxVisitor
+	super 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
@@ -383,40 +392,43 @@ 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[AParam] = new Array[AParam]
 	
 	# Visited parameters without type information added
-	readable writable attr _untyped_params: Array[PParam] = new Array[PParam]
+	readable writable var _untyped_params: Array[AParam] = new Array[AParam]
 
 	# 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]
+
+	# True is a problen occured durring building
+	readable writable var _has_error_occured: Bool = false
 
 	# 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)
+redef class ANode
+	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 AImport = null
 		for i in n_imports do
 			var n = i.module_name
 			if n != null then
@@ -428,7 +440,7 @@ redef class AModule
 		end
 		if no_import != null then
 			if not module_names_to_import.is_empty then
-				tc.error("{no_import.locate}: Error: Top modules cannot import other modules.")
+				tc.error(no_import.location, "Error: Top modules cannot import other modules.")
 			end
 		else if module_names_to_import.is_empty then
 			var stdname = once "standard".to_symbol
@@ -446,82 +458,86 @@ redef class AModule
 	end
 end
 
-redef class APackagedecl
-	redef meth accept_class_builder(v)
+redef class AModuledecl
+	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}")
+		if n_id.to_symbol != v.mmmodule.name then
+			v.error(n_id, "Error: Module name missmatch between {v.mmmodule.name} and {n_id.to_symbol}")
 		end
 	end
 end
 
-redef class PImport
+redef class AImport
 	# 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 class AStdImport
+	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
 end
 
-redef class PVisibility
+redef class AVisibility
 	# 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 class AClassdef
+	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
+		var mod = v.mmmodule
 		var local_classes = mod.src_local_classes
 		if (local_classes.has_key(name)) then
 			local_class = local_classes[name]
-			if self isa AClassdef then
+			if self isa AStdClassdef then
 				# If we are not a special implicit class then rant
-				v.error(self, "Error: A class {name} is already defined at line {local_class.nodes.first.first_token.line}.")
+				v.error(self, "Error: A class {name} is already defined at line {local_class.node.location.line_start}.")
 				return
 			end
-			local_class.nodes.add(self)
+			# Add the new node after the last node
+			var n = local_class.node
+			while n.next_node != null do n = n.next_node
+			n.next_node = self
 		else
 			local_class = new MMSrcLocalClass(mod, name, self, arity)
 			local_classes[name] = local_class
@@ -534,17 +550,16 @@ redef class PClassdef
 		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
@@ -552,32 +567,32 @@ redef class PClassdef
 	end
 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
+redef class AClasskind
+	fun is_interface: Bool do return false
+	fun is_enum: 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 class AEnumClasskind
+	redef fun is_enum 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 class AStdClassdef
+	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
@@ -586,7 +601,7 @@ redef class AClassdef
 			glob.visibility_level = visibility_level
 			glob.is_interface = n_classkind.is_interface
 			glob.is_abstract = n_classkind.is_abstract
-			glob.is_universal = n_classkind.is_universal
+			glob.is_enum = n_classkind.is_enum
 			if n_kwredef != null then
 				v.error(self, "Redef error: No class {name} is imported. Remove the redef keyword to define a new class.")
 			end
@@ -594,18 +609,18 @@ redef class AClassdef
 			for c in _local_class.cshe.direct_greaters do
 				var cg = c.global
 				if glob.is_interface then
-					if cg.is_universal then
-						v.error(self, "Special error: Interface {name} try to specialise universal class {c.name}.")
+					if cg.is_enum then
+						v.error(self, "Special error: Interface {name} try to specialise enum class {c.name}.")
 					else if not cg.is_interface then
 						v.error(self, "Special error: Interface {name} try to specialise class {c.name}.")
 					end
-				else if glob.is_universal then
-					if not cg.is_interface and not cg.is_universal then
-						v.error(self, "Special error: Universal class {name} try to specialise class {c.name}.")
+				else if glob.is_enum then
+					if not cg.is_interface and not cg.is_enum then
+						v.error(self, "Special error: Enum class {name} try to specialise class {c.name}.")
 					end
 				else
-					if cg.is_universal then
-						v.error(self, "Special error: Class {name} try to specialise universal class {c.name}.")
+					if cg.is_enum then
+						v.error(self, "Special error: Class {name} try to specialise enum class {c.name}.")
 					end
 				end
 
@@ -615,7 +630,7 @@ redef class AClassdef
 
 		# Redef
 
-		glob.check_visibility(v, self, v.module)
+		glob.check_visibility(v, self, v.mmmodule)
 		if n_kwredef == null then
 			v.error(self, "Redef error: {name} is an imported class. Add the redef keyword to refine it.")
 			return
@@ -628,52 +643,40 @@ redef class AClassdef
 		if 
 			not glob.is_interface and n_classkind.is_interface or
 			not glob.is_abstract and n_classkind.is_abstract or
-			not glob.is_universal and n_classkind.is_universal
+			not glob.is_enum and n_classkind.is_enum
 		then
 			v.error(self, "Redef error: cannot change kind of class {name}.")
 		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
 end
 
-class MMSrcTypeFormalParameter
-special MMTypeFormalParameter
-	# The associated node
-	readable attr _node: AFormaldef 
-
-	init(name: Symbol, pos: Int, local_class: MMLocalClass, n: AFormaldef)
-	do
-		super(name, pos, local_class)
-		_node = n
-	end
-end
-
 redef class AFormaldef
 	# The associated formal generic parameter (MM entity)
-	attr _formal: MMSrcTypeFormalParameter
+	var _formal: nullable MMTypeFormalParameter
 
-	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)
+		var formal_type = new MMTypeFormalParameter(name, v.local_class_arity, v.local_class)
 		_formal = formal_type
 		v.local_class_arity = v.local_class_arity + 1
 		v.local_class.register_formal(formal_type)
@@ -681,23 +684,27 @@ 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.mmmodule.type_any.as_nullable
 			else
-				_formal.bound = n_type.get_stype(v)
+				var stype = n_type.get_stype(v)
+				if stype == null then return
+				_formal.bound = stype
 			end
 		else
-			var ob = o.get_formal(_formal.position).bound.for_module(v.module)
+			var ob = o.get_formal(_formal.position).bound.for_module(v.mmmodule)
 			if n_type == null then
 				_formal.bound = ob
 			else
-				_formal.bound = n_type.get_stype(v)
+				var stype = n_type.get_stype(v)
+				if stype == null then return
+				_formal.bound = stype
 				if _formal.bound != ob then
 					v.error(self, "Redef error: Cannot change formal parameter type of class {c}; got {_formal.bound}, expected {ob}.")
 				end
@@ -707,39 +714,40 @@ 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)
-		var ancestor = new MMSrcAncestor(self, c)
+		if c == null then return
+		var ancestor = new MMSrcAncestor(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)
 	end
 end
 
-redef class PPropdef
+redef class APropdef
 	# Process and check properties of the property.
 	# * Distinguish inits and methods
 	# * Inherit or check visibility.
 	# * 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)
@@ -749,7 +757,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
@@ -764,14 +772,14 @@ redef class PPropdef
 		if glob.is_attribute then
 			if gbc.is_interface then
 				v.error(self, "Error: Attempt to define attribute {prop} in the interface {prop.local_class}.")
-			else if gbc.is_universal then
-				v.error(self, "Error: Attempt to define attribute {prop} in the universal class {prop.local_class}.")
+			else if gbc.is_enum then
+				v.error(self, "Error: Attempt to define attribute {prop} in the enum class {prop.local_class}.")
 			end
 		else if glob.is_init then
 			if gbc.is_interface then
 				v.error(self, "Error: Attempt to define a constructor {prop} in the class {prop.local_class}.")
-			else if gbc.is_universal then
-				v.error(self, "Error: Attempt to define a constructor {prop} in the universal {prop.local_class}.")
+			else if gbc.is_enum then
+				v.error(self, "Error: Attempt to define a constructor {prop} in the enum {prop.local_class}.")
 			end
 		end
 		if prop.signature == null then
@@ -779,22 +787,20 @@ redef class PPropdef
 				var supers = prop.local_class.super_methods_named(prop.name)
 				inherit_signature(v, prop, supers)
 			end
-			if prop.signature != null then
+			if prop.signature != null or v.signature_builder.has_error_occured then
 				# ok
 			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)
-				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
@@ -802,7 +808,6 @@ redef class PPropdef
 
 			if s == null 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.signature_builder.params do
@@ -821,7 +826,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
@@ -837,7 +842,7 @@ redef class PPropdef
 		end
 
 		var s = prop.signature
-		#print "process {prop.local_class.module}::{prop.local_class}::{prop} from global {prop.global.local_property.local_class.module}::{prop.global.local_property.local_class}::{prop.global.local_property}"
+		#print "process {prop.local_class.mmmodule}::{prop.local_class}::{prop} from global {prop.global.local_property.local_class.mmmodule}::{prop.global.local_property.local_class}::{prop.global.local_property}"
 		for i in prop.prhe.direct_greaters do
 			var ip = i.local_class[prop.global]
 			var isig = i.signature.adaptation_to(v.local_class.get_type)
@@ -876,9 +881,9 @@ redef class PPropdef
 			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
-					if s[i] != isig[i] then
-						v.error(self, "Redef error: Expected {isig[i]} (as in {ip.local_class}::{ip}), got {s[i]} in {prop.local_class}::{prop}.")
+				for j in [0..s.arity[ do
+					if s[j] != isig[j] then
+						v.error(self, "Redef error: Expected {isig[j]} (as in {ip.local_class}::{ip}), got {s[j]} in {prop.local_class}::{prop}.")
 					end
 				end
 			end
@@ -903,65 +908,90 @@ redef class PPropdef
 		if visibility_level != 1 and glob.visibility_level != visibility_level then
 			v.error(self, "Redef error: {prop.local_class}::{prop} redefinition cannot change visibility.")
 		end
-		glob.check_visibility(v, self, v.module, true)
+		glob.check_visibility(v, self, v.mmmodule, true)
 	end
 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 name: Symbol
+		if n_id != null then
+			name = n_id.to_symbol
+		else
+			name = ("@" + n_id2.text).to_symbol
+		end
+		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)
+		if n_readable != null or n_id == null then
+			if n_id != null then
+				name = n_id.text.substring_from(1).to_symbol
+			else
+				name = n_id2.to_symbol
+			end
+			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)
+		if n_writable != null or n_id == null then
+			if n_id != null then
+				name = (n_id.text.substring_from(1) + "=").to_symbol
+			else
+				name = (n_id2.text + "=").to_symbol
+			end
+			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.")
+			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)
-		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)
+		process_and_check(v, prop, n_id != null and n_kwredef != null, visibility_level)
+		if n_readable != null or n_id == null then
+			var m = _readmethod.as(not null)
+			m.signature = signature
+			process_and_check(v, m, (n_readable != null and n_readable.n_kwredef != null) or (n_id == null and 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)
+		if n_writable != null or n_id == null then
+			var m = _writemethod.as(not null)
+			m.signature = new MMSignature(new Array[MMType].with_items(t), null, v.local_class.get_type)
+			var vl = visibility_level
+			if n_id == null then
+				if n_writable == null then vl = 3 else vl = n_writable.n_visibility.level # write accessor has a specific visibility
+			end
+			process_and_check(v, m, n_writable != null and n_writable.n_kwredef != null, vl)
+			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
@@ -969,62 +999,67 @@ 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
+				if ns != null and ns.n_params.length == 0 then
+					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
 
+		if v.signature_builder.has_error_occured then return
+
 		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,10 +1067,26 @@ redef class AMainMethPropdef
 	end
 end
 
+redef class AExternMethPropdef
+	redef fun accept_property_verifier(v)
+	do
+		super # Compute signature
+		var ename: String
+		if n_extern != null then
+			ename = n_extern.text
+			ename = ename.substring(1, ename.length-2)
+		else
+			ename = "{method.mmmodule.name}_{method.local_class.name}_{method.local_class.name}_{method.name}_{method.signature.arity}"
+		end
+		method.extern_name = ename
+	end
+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
@@ -1044,18 +1095,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,9 +1114,9 @@ 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)
+	super Visitor
+	readable var _name: Buffer = new Buffer
+	redef fun visit(n)
 	do
 		if n isa Token then
 			_name.append(n.text)
@@ -1075,29 +1126,26 @@ special Visitor
 	end
 end
 
-redef class PMethid
+redef class AMethid
 	# 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)
+		accumulator.enter_visit(self)
 		_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
-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
+		if v.signature_builder.has_error_occured then
+			return
+		else 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
@@ -1105,11 +1153,15 @@ 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)
+				if ret == null then
+					v.signature_builder.has_error_occured = true
+					return
+				end
 			end
 			v.signature_builder.signature = new MMSignature(pars, ret, v.local_class.get_type)
 			if v.signature_builder.vararg_rank >= 0 then
@@ -1121,7 +1173,8 @@ redef class ASignature
 		end
 	end
 
-	redef meth check_visibility(v, p)
+	# Check that visibilities of types in the signature are compatible with the visibility of the property.
+	fun check_visibility(v: AbsSyntaxVisitor, p: MMLocalProperty)
 	do
 		if p.global.visibility_level >= 3 then return
 		for n in n_params do
@@ -1131,23 +1184,28 @@ redef class ASignature
 	end
 end
 
-redef class PParam
-	redef readable attr _position: Int
+redef class AParam
+	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
-		_variable = new ParamVariable(n_id.to_symbol, self)
+		_variable = new ParamVariable(n_id.to_symbol, n_id)
 		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)
+			if stype == null then
+				v.signature_builder.has_error_occured = true
+				return
+			end
 			for p in v.signature_builder.untyped_params do
 				p.stype = stype
 				if is_vararg then
@@ -1156,7 +1214,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
@@ -1164,21 +1222,23 @@ redef class PParam
 		end
 	end
 
-	meth is_vararg: Bool is abstract
-end
-
-redef class AParam
-	redef meth is_vararg do return n_dotdotdot != null
+	fun is_vararg: Bool do return n_dotdotdot != null
 end
 
 redef class AClosureDecl
-	redef readable attr _variable: ClosureVariable
+	redef readable var _position: Int = 0
 
-	redef meth accept_property_verifier(v)
+	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
+		if v.signature_builder.has_error_occured then
+			return
+		end
 		var sig = v.signature_builder.signature
 		if sig == null then
 			sig = new MMSignature(new Array[MMType], null, v.local_class.get_type)
@@ -1188,30 +1248,33 @@ redef class AClosureDecl
 		end
 
 		# Add the finalizer to the closure signature
-		var finalize_sig = new MMSignature(new Array[MMType], null, null)
-		var finalizer_clos = new MMClosure(finalize_sig, false, true)
+		var finalize_sig = new MMSignature(new Array[MMType], null, v.mmmodule.type_any) # FIXME should be no receiver
+		var finalizer_clos = new MMClosure(once ("break".to_symbol), finalize_sig, false, true)
 		sig.closures.add(finalizer_clos)
 
-		var clos = new MMClosure(sig, n_kwbreak != null, n_expr != null)
+		var name = n_id.to_symbol
+		var clos = new MMClosure(name, sig, n_kwbreak != null, n_expr != null)
+		for c in old_signature_builder.closure_decls do
+			if c.n_id.to_symbol == name then
+				v.error(n_id, "A closure '!{name}' already defined at {c.n_id.location.relative_to(n_id.location)}.")
+				return
+			end
+		end
 		v.signature_builder = old_signature_builder
+		_position = old_signature_builder.closure_decls.length
 		old_signature_builder.closure_decls.add(self)
-		_variable = new ClosureVariable(n_id.to_symbol, self, clos)
+		_variable = new ClosureVariable(n_id.to_symbol, n_id, 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
-end
-
 redef class AType
-	redef meth check_visibility(v, p)
+	# Check that visibilities of types in the signature are compatible with the visibility of the property.
+	private fun check_visibility(v: AbsSyntaxVisitor, p: MMLocalProperty)
 	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,8 +1284,8 @@ redef class AType
 	end
 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 class AExpr
+	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