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

diff --git a/src/modelbuilder.nit b/src/modelbuilder.nit
index 3f39d6d..35c273e 100644
--- a/src/modelbuilder.nit
+++ b/src/modelbuilder.nit
@@ -22,34 +22,76 @@
 # FIXME add missing error checks
 module modelbuilder
 
-import parser
 import model
-import poset
-import opts
-import toolcontext
+import phase
+
+private import more_collections
 
 ###
 
 redef class ToolContext
 	# Option --path
-	readable var _opt_path: OptionArray = new OptionArray("Set include path for loaders (may be used more than once)", "-I", "--path")
+	var opt_path = new OptionArray("Set include path for loaders (may be used more than once)", "-I", "--path")
 
 	# Option --only-metamodel
-	readable var _opt_only_metamodel: OptionBool = new OptionBool("Stop after meta-model processing", "--only-metamodel")
+	var opt_only_metamodel = new OptionBool("Stop after meta-model processing", "--only-metamodel")
 
 	# Option --only-parse
-	readable var _opt_only_parse: OptionBool = new OptionBool("Only proceed to parse step of loaders", "--only-parse")
+	var opt_only_parse = new OptionBool("Only proceed to parse step of loaders", "--only-parse")
+
+	# Option --ignore-visibility
+	var opt_ignore_visibility = new OptionBool("Do not check, and produce errors, on visibility issues.", "--ignore-visibility")
 
 	redef init
 	do
 		super
-		option_context.add_option(opt_path, opt_only_parse, opt_only_metamodel)
+		option_context.add_option(opt_path, opt_only_parse, opt_only_metamodel, opt_ignore_visibility)
+	end
+
+	# The modelbuilder 1-to-1 associated with the toolcontext
+	fun modelbuilder: ModelBuilder do return modelbuilder_real.as(not null)
+
+	private var modelbuilder_real: nullable ModelBuilder = null
+
+	# Run `process_mainmodule` on all phases
+	fun run_global_phases(mmodules: Array[MModule])
+	do
+		assert not mmodules.is_empty
+		var mainmodule
+		if mmodules.length == 1 then
+			mainmodule = mmodules.first
+		else
+			# We need a main module, so we build it by importing all modules
+			mainmodule = new MModule(modelbuilder.model, null, mmodules.first.name, new Location(mmodules.first.location.file, 0, 0, 0, 0))
+			mainmodule.is_fictive = true
+			mainmodule.set_imported_mmodules(mmodules)
+		end
+		for phase in phases_list do
+			if phase.disabled then continue
+			phase.process_mainmodule(mainmodule, mmodules)
+		end
 	end
 end
 
+redef class Phase
+	# Specific action to execute on the whole program.
+	# Called by the `ToolContext::run_global_phases`.
+	#
+	# `mainmodule` is the main module of the program.
+	# It could be an implicit module (called like the first given_mmodules).
+	#
+	# `given_modules` is the list of explicitely requested modules.
+	# from the command-line for instance.
+	#
+	# REQUIRE: `not given_modules.is_empty`
+	# REQUIRE: `(given_modules.length == 1) == (mainmodule == given_modules.first)`
+	#
+	# @toimplement
+	fun process_mainmodule(mainmodule: MModule, given_mmodules: SequenceRead[MModule]) do end
+end
+
+
 # A model builder knows how to load nit source files and build the associated model
-# The important function is `parse_and_build' that does all the job.
-# The others function can be used for specific tasks
 class ModelBuilder
 	# The model where new modules, classes and properties are added
 	var model: Model
@@ -57,12 +99,31 @@ class ModelBuilder
 	# The toolcontext used to control the interaction with the user (getting options and displaying messages)
 	var toolcontext: ToolContext
 
+	# Run phases on all loaded modules
+	fun run_phases
+	do
+		var mmodules = model.mmodules.to_a
+		model.mmodule_importation_hierarchy.sort(mmodules)
+		var nmodules = new Array[AModule]
+		for mm in mmodules do
+			nmodules.add(mmodule2nmodule[mm])
+		end
+		toolcontext.run_phases(nmodules)
+
+		if toolcontext.opt_only_metamodel.value then
+			self.toolcontext.info("*** ONLY METAMODEL", 1)
+			exit(0)
+		end
+	end
+
 	# Instantiate a modelbuilder for a model and a toolcontext
 	# Important, the options of the toolcontext must be correctly set (parse_option already called)
 	init(model: Model, toolcontext: ToolContext)
 	do
 		self.model = model
 		self.toolcontext = toolcontext
+		assert toolcontext.modelbuilder_real == null
+		toolcontext.modelbuilder_real = self
 
 		# Setup the paths value
 		paths.append(toolcontext.opt_path.value)
@@ -72,31 +133,28 @@ class ModelBuilder
 			paths.append(path_env.split_with(':'))
 		end
 
-		path_env = "NIT_DIR".environ
-		if not path_env.is_empty then
-			var libname = "{path_env}/lib"
+		var nit_dir = toolcontext.nit_dir
+		if nit_dir != null then
+			var libname = "{nit_dir}/lib"
 			if libname.file_exists then paths.add(libname)
 		end
-
-		var libname = "{sys.program_name.dirname}/../lib"
-		if libname.file_exists then paths.add(libname.simplify_path)
 	end
 
-	# Load and analyze a bunch of modules.
-	# `modules' can contains filenames or module names.
-	# Imported modules are automatically loaded, builds and analysed.
-	# The result is the corresponding built modules.
+	# Load a bunch of modules.
+	# `modules` can contains filenames or module names.
+	# Imported modules are automatically loaded and modelized.
+	# The result is the corresponding model elements.
 	# Errors and warnings are printed with the toolcontext.
 	#
-	# FIXME: Maybe just let the client do the loop (instead of playing with Sequences)
-	fun parse_and_build(modules: Sequence[String]): Array[MModule]
+	# Note: class and property model element are not analysed.
+	fun parse(modules: Sequence[String]): Array[MModule]
 	do
 		var time0 = get_time
 		# Parse and recursively load
 		self.toolcontext.info("*** PARSE ***", 1)
-		var mmodules = new Array[MModule]
+		var mmodules = new ArraySet[MModule]
 		for a in modules do
-			var nmodule = self.load_module(null, a)
+			var nmodule = self.load_module(a)
 			if nmodule == null then continue # Skip error
 			mmodules.add(nmodule.mmodule.as(not null))
 		end
@@ -105,26 +163,18 @@ class ModelBuilder
 
 		self.toolcontext.check_errors
 
-		if self.toolcontext.opt_only_parse.value then
-			self.toolcontext.info("--only-parse: stop processing", 2)
-			return new Array[MModule]
+		if toolcontext.opt_only_parse.value then
+			self.toolcontext.info("*** ONLY PARSE...", 1)
+			exit(0)
 		end
 
-		# Build the model
-		self.toolcontext.info("*** BUILD MODEL ***", 1)
-		self.build_all_classes
-		var time2 = get_time
-		self.toolcontext.info("*** END BUILD MODEL: {time2-time1} ***", 2)
-
-		self.toolcontext.check_errors
-
-		return mmodules
+		return mmodules.to_a
 	end
 
-	# Return a class named `name' visible by the module `mmodule'.
+	# Return a class named `name` visible by the module `mmodule`.
 	# Visibility in modules is correctly handled.
 	# If no such a class exists, then null is returned.
-	# If more than one class exists, then an error on `anode' is displayed and null is returned.
+	# If more than one class exists, then an error on `anode` is displayed and null is returned.
 	# FIXME: add a way to handle class name conflict
 	fun try_get_mclass_by_name(anode: ANode, mmodule: MModule, name: String): nullable MClass
 	do
@@ -147,11 +197,11 @@ class ModelBuilder
 		return res
 	end
 
-	# Return a property named `name' on the type `mtype' visible in the module `mmodule'.
+	# Return a property named `name` on the type `mtype` visible in the module `mmodule`.
 	# Visibility in modules is correctly handled.
 	# Protected properties are returned (it is up to the caller to check and reject protected properties).
 	# If no such a property exists, then null is returned.
-	# If more than one property exists, then an error on `anode' is displayed and null is returned.
+	# If more than one property exists, then an error on `anode` is displayed and null is returned.
 	# FIXME: add a way to handle property name conflict
 	fun try_get_mproperty_by_name2(anode: ANode, mmodule: MModule, mtype: MType, name: String): nullable MProperty
 	do
@@ -170,35 +220,62 @@ class ModelBuilder
 			if not mmodule.is_visible(mprop.intro_mclassdef.mmodule, mprop.visibility) then continue
 			if res == null then
 				res = mprop
-			else
+				continue
+			end
+
+			# Two global properties?
+			# First, special case for init, keep the most specific ones
+			if res isa MMethod and mprop isa MMethod and res.is_init and mprop.is_init then
 				var restype = res.intro_mclassdef.bound_mtype
 				var mproptype = mprop.intro_mclassdef.bound_mtype
-				if restype.is_subtype(mmodule, null, mproptype) then
-					# we keep res
-				else if mproptype.is_subtype(mmodule, null, restype) then
+				if mproptype.is_subtype(mmodule, null, restype) then
+					# found a most specific constructor, so keep it
 					res = mprop
-				else
-					if ress == null then ress = new Array[MProperty]
-					ress.add(mprop)
+					continue
 				end
 			end
+
+			# Ok, just keep all prop in the ress table
+			if ress == null then
+				ress = new Array[MProperty]
+				ress.add(res)
+			end
+			ress.add(mprop)
 		end
-		if ress != null then
+
+		# There is conflict?
+		if ress != null and res isa MMethod and res.is_init then
+			# special case forinit again
 			var restype = res.intro_mclassdef.bound_mtype
+			var ress2 = new Array[MProperty]
 			for mprop in ress do
 				var mproptype = mprop.intro_mclassdef.bound_mtype
 				if not restype.is_subtype(mmodule, null, mproptype) then
-					self.error(anode, "Ambigous property name '{name}' for {mtype}; conflict between {mprop.full_name} and {res.full_name}")
-					return null
+					ress2.add(mprop)
+				else if not mprop isa MMethod or not mprop.is_init then
+					ress2.add(mprop)
 				end
 			end
+			if ress2.is_empty then
+				ress = null
+			else
+				ress = ress2
+				ress.add(res)
+			end
+		end
+
+		if ress != null then
+			assert ress.length > 1
+			var s = new Array[String]
+			for mprop in ress do s.add mprop.full_name
+			self.error(anode, "Ambigous property name '{name}' for {mtype}; conflict between {s.join(" and ")}")
 		end
 
 		self.try_get_mproperty_by_name2_cache[mmodule, mtype, name] = res
 		return res
 	end
 
-	private var try_get_mproperty_by_name2_cache: HashMap3[MModule, MType, String, nullable MProperty] = new HashMap3[MModule, MType, String, nullable MProperty]
+	private var try_get_mproperty_by_name2_cache = new HashMap3[MModule, MType, String, nullable MProperty]
 
 
 	# Alias for try_get_mproperty_by_name2(anode, mclassdef.mmodule, mclassdef.mtype, name)
@@ -211,96 +288,98 @@ class ModelBuilder
 	# The list is initially set with :
 	#   * the toolcontext --path option
 	#   * the NIT_PATH environment variable
-	#   * some heuristics including the NIT_DIR environment variable and the progname of the process
+	#   * `toolcontext.nit_dir`
 	# Path can be added (or removed) by the client
-	var paths: Array[String] = new Array[String]
+	var paths = new Array[String]
 
-	# Get a module by its short name; if required, the module is loaded, parsed and its hierarchies computed.
-	# If `mmodule' is set, then the module search starts from it up to the top level (see `paths');
-	# if `mmodule' is null then the module is searched in the top level only.
-	# If no module exists or there is a name conflict, then an error on `anode' is displayed and null is returned.
-	# FIXME: add a way to handle module name conflict
-	fun get_mmodule_by_name(anode: ANode, mmodule: nullable MModule, name: String): nullable MModule
+	# Like (an used by) `get_mmodule_by_name` but just return the ModulePath
+	private fun search_mmodule_by_name(anode: ANode, mgroup: nullable MGroup, name: String): nullable ModulePath
 	do
-		var origmmodule = mmodule
-		var modules = model.get_mmodules_by_name(name)
-
-		var tries = new Array[String]
-
-		var lastmodule = mmodule
-		while mmodule != null do
-			var dirname = mmodule.location.file.filename.dirname
-
-			# Determine the owner
-			var owner: nullable MModule
-			if dirname.basename("") != mmodule.name then
-				owner = mmodule.direct_owner
-			else
-				owner = mmodule
-			end
-
-			# First, try the already known nested modules
-			if modules != null then
-				for candidate in modules do
-					if candidate.direct_owner == owner then
-						return candidate
-					end
-				end
-			end
+		# First, look in groups
+		var c = mgroup
+		while c != null do
+			var dirname = c.filepath
+			if dirname == null then break # virtual group
+			if dirname.has_suffix(".nit") then break # singleton project
 
 			# Second, try the directory to find a file
 			var try_file = dirname + "/" + name + ".nit"
-			tries.add try_file
 			if try_file.file_exists then
-				var res = self.load_module(owner, try_file.simplify_path)
-				if res == null then return null # Forward error
-				return res.mmodule.as(not null)
+				var res = self.identify_file(try_file.simplify_path)
+				assert res != null
+				return res
 			end
 
-			# Third, try if the requested module is itself an owner
+			# Third, try if the requested module is itself a group
 			try_file = dirname + "/" + name + "/" + name + ".nit"
 			if try_file.file_exists then
-				var res = self.load_module(owner, try_file.simplify_path)
-				if res == null then return null # Forward error
-				return res.mmodule.as(not null)
+				var res = self.identify_file(try_file.simplify_path)
+				assert res != null
+				return res
 			end
 
-			lastmodule = mmodule
-			mmodule = mmodule.direct_owner
+			c = c.parent
 		end
 
-		if modules != null then
-			for candidate in modules do
-				if candidate.direct_owner == null then
-					return candidate
+		# Look at some known directories
+		var lookpaths = self.paths
+
+		# Look in the directory of the group project also (even if not explicitely in the path)
+		if mgroup != null then
+			# path of the root group
+			var dirname = mgroup.mproject.root.filepath
+			if dirname != null then
+				dirname = dirname.join_path("..").simplify_path
+				if not lookpaths.has(dirname) and dirname.file_exists then
+					lookpaths = lookpaths.to_a
+					lookpaths.add(dirname)
 				end
 			end
 		end
 
-		# Look at some known directories
-		var lookpaths = self.paths
+		var candidate = search_module_in_paths(anode.hot_location, name, lookpaths)
 
-		# Look in the directory of the last module also (event if not in the path)
-		if lastmodule != null then
-			var dirname = lastmodule.location.file.filename.dirname
-			if dirname.basename("") == lastmodule.name then
-				dirname = dirname.dirname
-			end
-			if not lookpaths.has(dirname) then
-				lookpaths = lookpaths.to_a
-				lookpaths.add(dirname)
+		if candidate == null then
+			if mgroup != null then
+				error(anode, "Error: cannot find module {name} from {mgroup.name}. tried {lookpaths.join(", ")}")
+			else
+				error(anode, "Error: cannot find module {name}. tried {lookpaths.join(", ")}")
 			end
+			return null
 		end
+		return candidate
+	end
 
+	# Get a module by its short name; if required, the module is loaded, parsed and its hierarchies computed.
+	# If `mgroup` is set, then the module search starts from it up to the top level (see `paths`);
+	# if `mgroup` is null then the module is searched in the top level only.
+	# If no module exists or there is a name conflict, then an error on `anode` is displayed and null is returned.
+	fun get_mmodule_by_name(anode: ANode, mgroup: nullable MGroup, name: String): nullable MModule
+	do
+		var path = search_mmodule_by_name(anode, mgroup, name)
+		if path == null then return null # Forward error
+		var res = self.load_module(path.filepath)
+		if res == null then return null # Forward error
+		return res.mmodule.as(not null)
+	end
+
+	# Search a module `name` from path `lookpaths`.
+	# If found, the path of the file is returned
+	private fun search_module_in_paths(location: nullable Location, name: String, lookpaths: Collection[String]): nullable ModulePath
+	do
 		var candidate: nullable String = null
 		for dirname in lookpaths do
 			var try_file = (dirname + "/" + name + ".nit").simplify_path
-			tries.add try_file
 			if try_file.file_exists then
 				if candidate == null then
 					candidate = try_file
 				else if candidate != try_file then
-					error(anode, "Error: conflicting module file for {name}: {candidate} {try_file}")
+					# try to disambiguate conflicting modules
+					var abs_candidate = module_absolute_path(candidate)
+					var abs_try_file = module_absolute_path(try_file)
+					if abs_candidate != abs_try_file then
+						toolcontext.error(location, "Error: conflicting module file for {name}: {candidate} {try_file}")
+					end
 				end
 			end
 			try_file = (dirname + "/" + name + "/" + name + ".nit").simplify_path
@@ -308,35 +387,153 @@ class ModelBuilder
 				if candidate == null then
 					candidate = try_file
 				else if candidate != try_file then
-					error(anode, "Error: conflicting module file for {name}: {candidate} {try_file}")
+					# try to disambiguate conflicting modules
+					var abs_candidate = module_absolute_path(candidate)
+					var abs_try_file = module_absolute_path(try_file)
+					if abs_candidate != abs_try_file then
+						toolcontext.error(location, "Error: conflicting module file for {name}: {candidate} {try_file}")
+					end
 				end
 			end
 		end
-		if candidate == null then
-			if origmmodule != null then
-				error(anode, "Error: cannot find module {name} from {origmmodule}. tried {tries.join(", ")}")
+		if candidate == null then return null
+		return identify_file(candidate)
+	end
+
+	# cache for `identify_file` by realpath
+	private var identified_files = new HashMap[String, nullable ModulePath]
+
+	# Identify a source file
+	# Load the associated project and groups if required
+	private fun identify_file(path: String): nullable ModulePath
+	do
+		# special case for not a nit file
+		if path.file_extension != "nit" then
+			# search in known -I paths
+			var res = search_module_in_paths(null, path, self.paths)
+			if res != null then return res
+
+			# Found nothins? maybe it is a group...
+			var candidate = null
+			if path.file_exists then
+				var mgroup = get_mgroup(path)
+				if mgroup != null then
+					var owner_path = mgroup.filepath.join_path(mgroup.name + ".nit")
+					if owner_path.file_exists then candidate = owner_path
+				end
+			end
+
+			if candidate == null then
+				toolcontext.error(null, "Error: cannot find module `{path}`.")
+				return null
+			end
+			path = candidate
+		end
+
+		# Fast track, the path is already known
+		var pn = path.basename(".nit")
+		var rp = module_absolute_path(path)
+		if identified_files.has_key(rp) then return identified_files[rp]
+
+		# Search for a group
+		var mgrouppath = path.join_path("..").simplify_path
+		var mgroup = get_mgroup(mgrouppath)
+
+		if mgroup == null then
+			# singleton project
+			var mproject = new MProject(pn, model)
+			mgroup = new MGroup(pn, mproject, null) # same name for the root group
+			mgroup.filepath = path
+			mproject.root = mgroup
+			toolcontext.info("found project `{pn}` at {path}", 2)
+		end
+
+		var res = new ModulePath(pn, path, mgroup)
+		mgroup.module_paths.add(res)
+
+		identified_files[rp] = res
+		return res
+	end
+
+	# groups by path
+	private var mgroups = new HashMap[String, nullable MGroup]
+
+	# return the mgroup associated to a directory path
+	# if the directory is not a group null is returned
+	private fun get_mgroup(dirpath: String): nullable MGroup
+	do
+		var rdp = module_absolute_path(dirpath)
+		if mgroups.has_key(rdp) then
+			return mgroups[rdp]
+		end
+
+		# Hack, a group is determined by:
+		# * the presence of a honomymous nit file
+		# * the fact that the directory is named `src`
+		var pn = rdp.basename(".nit")
+		var mp = dirpath.join_path(pn + ".nit").simplify_path
+
+		var dirpath2 = dirpath
+		if not mp.file_exists then
+			if pn == "src" then
+				# With a src directory, the group name is the name of the parent directory
+				dirpath2 = rdp.dirname
+				pn = dirpath2.basename("")
 			else
-				error(anode, "Error: cannot find module {name}. tried {tries.join(", ")}")
+				return null
 			end
-			return null
 		end
-		var res = self.load_module(mmodule, candidate)
-		if res == null then return null # Forward error
-		return res.mmodule.as(not null)
+
+		# check parent directory
+		var parentpath = dirpath.join_path("..").simplify_path
+		var parent = get_mgroup(parentpath)
+
+		var mgroup
+		if parent == null then
+			# no parent, thus new project
+			var mproject = new MProject(pn, model)
+			mgroup = new MGroup(pn, mproject, null) # same name for the root group
+			mproject.root = mgroup
+			toolcontext.info("found project `{mproject}` at {dirpath}", 2)
+		else
+			mgroup = new MGroup(pn, parent.mproject, parent)
+			toolcontext.info("found sub group `{mgroup.full_name}` at {dirpath}", 2)
+		end
+		var readme = dirpath2.join_path("README.md")
+		if not readme.file_exists then readme = dirpath2.join_path("README")
+		if readme.file_exists then
+			var mdoc = new MDoc
+			var s = new IFStream.open(readme)
+			while not s.eof do
+				mdoc.content.add(s.read_line)
+			end
+			mgroup.mdoc = mdoc
+			mdoc.original_mentity = mgroup
+		end
+		mgroup.filepath = dirpath
+		mgroups[rdp] = mgroup
+		return mgroup
+	end
+
+	# Transform relative paths (starting with '../') into absolute paths
+	private fun module_absolute_path(path: String): String do
+		return getcwd.join_path(path).simplify_path
 	end
 
-	# Try to load a module using a path.
+	# Try to load a module AST using a path.
 	# Display an error if there is a problem (IO / lexer / parser) and return null
-	# Note: usually, you do not need this method, use `get_mmodule_by_name` instead.
-	fun load_module(owner: nullable MModule, filename: String): nullable AModule
+	fun load_module_ast(filename: String): nullable AModule
 	do
+		if filename.file_extension != "nit" then
+			self.toolcontext.error(null, "Error: file {filename} is not a valid nit module.")
+			return null
+		end
 		if not filename.file_exists then
 			self.toolcontext.error(null, "Error: file {filename} not found.")
 			return null
 		end
 
-		var x = if owner != null then owner.to_s else "."
-		self.toolcontext.info("load module {filename} in {x}", 2)
+		self.toolcontext.info("load module {filename}", 2)
 
 		# Load the file
 		var file = new IFStream.open(filename)
@@ -354,8 +551,66 @@ class ModelBuilder
 			return null
 		end
 
+		return nmodule
+	end
+
+	# Try to load a module and its imported modules using a path.
+	# Display an error if there is a problem (IO / lexer / parser / importation) and return null
+	# Note: usually, you do not need this method, use `get_mmodule_by_name` instead.
+	fun load_module(filename: String): nullable AModule
+	do
+		# Look for the module
+		var file = identify_file(filename)
+		if file == null then return null # forward error
+
+		# Already known and loaded? then return it
+		var mmodule = file.mmodule
+		if mmodule != null then
+			return mmodule2nmodule[mmodule]
+		end
+
+		# Load it manually
+		var nmodule = load_module_ast(file.filepath)
+		if nmodule == null then return null # forward error
+
+		# build the mmodule and load imported modules
+		mmodule = build_a_mmodule(file.mgroup, file.name, nmodule)
+
+		if mmodule == null then return null # forward error
+
+		# Update the file information
+		file.mmodule = mmodule
+
+		# Load imported module
+		build_module_importation(nmodule)
+
+		return nmodule
+	end
+
+	# Injection of a new module without source.
+	# Used by the interpreted
+	fun load_rt_module(parent: MModule, nmodule: AModule, mod_name: String): nullable AModule
+	do
+		# Create the module
+		var mmodule = new MModule(model, parent.mgroup, mod_name, nmodule.location)
+		nmodule.mmodule = mmodule
+		nmodules.add(nmodule)
+		self.mmodule2nmodule[mmodule] = nmodule
+
+		var imported_modules = new Array[MModule]
+
+		imported_modules.add(parent)
+		mmodule.set_visibility_for(parent, intrude_visibility)
+
+		mmodule.set_imported_mmodules(imported_modules)
+
+		return nmodule
+	end
+
+	# Visit the AST and create the `MModule` object
+	private fun build_a_mmodule(mgroup: nullable MGroup, mod_name: String, nmodule: AModule): nullable MModule
+	do
 		# Check the module name
-		var mod_name = filename.basename(".nit")
 		var decl = nmodule.n_moduledecl
 		if decl == null then
 			#warning(nmodule, "Warning: Missing 'module' keyword") #FIXME: NOT YET FOR COMPATIBILITY
@@ -367,14 +622,23 @@ class ModelBuilder
 		end
 
 		# Create the module
-		var mmodule = new MModule(model, owner, mod_name, nmodule.location)
+		var mmodule = new MModule(model, mgroup, mod_name, nmodule.location)
 		nmodule.mmodule = mmodule
 		nmodules.add(nmodule)
 		self.mmodule2nmodule[mmodule] = nmodule
 
-		build_module_importation(nmodule)
+		if decl != null then
+			var ndoc = decl.n_doc
+			if ndoc != null then
+				var mdoc = ndoc.to_mdoc
+				mmodule.mdoc = mdoc
+				mdoc.original_mentity = mmodule
+			else
+				advice(decl, "missing-doc", "Documentation warning: Undocumented module `{mmodule}`")
+			end
+		end
 
-		return nmodule
+		return mmodule
 	end
 
 	# Analysis the module importation and fill the module_importation_hierarchy
@@ -390,11 +654,30 @@ class ModelBuilder
 			if not aimport isa AStdImport then
 				continue
 			end
+			var mgroup = mmodule.mgroup
+			if aimport.n_name.n_quad != null then mgroup = null # Start from top level
+			for grp in aimport.n_name.n_path do
+				var path = search_mmodule_by_name(grp, mgroup, grp.text)
+				if path == null then return # Skip error
+				mgroup = path.mgroup
+			end
 			var mod_name = aimport.n_name.n_id.text
-			var sup = self.get_mmodule_by_name(aimport.n_name, mmodule, mod_name)
+			var sup = self.get_mmodule_by_name(aimport.n_name, mgroup, mod_name)
 			if sup == null then continue # Skip error
+			aimport.mmodule = sup
 			imported_modules.add(sup)
 			var mvisibility = aimport.n_visibility.mvisibility
+			if mvisibility == protected_visibility then
+				error(aimport.n_visibility, "Error: only properties can be protected.")
+				return
+			end
+			if sup == mmodule then
+				error(aimport.n_name, "Error: Dependency loop in module {mmodule}.")
+			end
+			if sup.in_importation < mmodule then
+				error(aimport.n_name, "Error: Dependency loop between modules {mmodule} and {sup}.")
+				return
+			end
 			mmodule.set_visibility_for(sup, mvisibility)
 		end
 		if stdimport then
@@ -407,505 +690,50 @@ class ModelBuilder
 		end
 		self.toolcontext.info("{mmodule} imports {imported_modules.join(", ")}", 3)
 		mmodule.set_imported_mmodules(imported_modules)
-	end
-
-	# All the loaded modules
-	var nmodules: Array[AModule] = new Array[AModule]
 
-	# Build the classes of all modules `nmodules'.
-	private fun build_all_classes
-	do
-		for nmodule in self.nmodules do
-			build_classes(nmodule)
-		end
-	end
-
-	# Visit the AST and create the MClass objects
-	private fun build_a_mclass(nmodule: AModule, nclassdef: AClassdef)
-	do
-		var mmodule = nmodule.mmodule.as(not null)
-
-		var name: String
-		var nkind: nullable AClasskind
-		var mkind: MClassKind
-		var nvisibility: nullable AVisibility
-		var mvisibility: nullable MVisibility
-		var arity = 0
-		if nclassdef isa AStdClassdef then
-			name = nclassdef.n_id.text
-			nkind = nclassdef.n_classkind
-			mkind = nkind.mkind
-			nvisibility = nclassdef.n_visibility
-			mvisibility = nvisibility.mvisibility
-			arity = nclassdef.n_formaldefs.length
-		else if nclassdef isa ATopClassdef then
-			name = "Object"
-			nkind = null
-			mkind = interface_kind
-			nvisibility = null
-			mvisibility = public_visibility
-		else if nclassdef isa AMainClassdef then
-			name = "Sys"
-			nkind = null
-			mkind = concrete_kind
-			nvisibility = null
-			mvisibility = public_visibility
-		else
-			abort
-		end
-
-		var mclass = try_get_mclass_by_name(nclassdef, mmodule, name)
-		if mclass == null then
-			mclass = new MClass(mmodule, name, arity, mkind, mvisibility)
-			#print "new class {mclass}"
-		else if nclassdef isa AStdClassdef and nmodule.mclass2nclassdef.has_key(mclass) then
-			error(nclassdef, "Error: A class {name} is already defined at line {nmodule.mclass2nclassdef[mclass].location.line_start}.")
-			return
-		else if nclassdef isa AStdClassdef and nclassdef.n_kwredef == null then
-			error(nclassdef, "Redef error: {name} is an imported class. Add the redef keyword to refine it.")
-			return
-		else if mclass.arity != arity then
-			error(nclassdef, "Redef error: Formal parameter arity missmatch; got {arity}, expected {mclass.arity}.")
-			return
-		else if nkind != null and mkind != concrete_kind and mclass.kind != mkind then
-			error(nkind, "Error: refinement changed the kind from a {mclass.kind} to a {mkind}")
-		else if nvisibility != null and mvisibility != public_visibility and mclass.visibility != mvisibility then
-			error(nvisibility, "Error: refinement changed the visibility from a {mclass.visibility} to a {mvisibility}")
-		end
-		nclassdef.mclass = mclass
-		nmodule.mclass2nclassdef[mclass] = nclassdef
-	end
-
-	# Visit the AST and create the MClassDef objects
-	private fun build_a_mclassdef(nmodule: AModule, nclassdef: AClassdef)
-	do
-		var mmodule = nmodule.mmodule.as(not null)
-		var objectclass = try_get_mclass_by_name(nmodule, mmodule, "Object")
-		var mclass = nclassdef.mclass
-		if mclass == null then return # Skip error
-		#var mclassdef = nclassdef.mclassdef.as(not null)
-
-		var names = new Array[String]
-		var bounds = new Array[MType]
-		if nclassdef isa AStdClassdef and mclass.arity > 0 then
-			# Collect formal parameter names
-			for i in [0..mclass.arity[ do
-				var nfd = nclassdef.n_formaldefs[i]
-				var ptname = nfd.n_id.text
-				if names.has(ptname) then
-					error(nfd, "Error: A formal parameter type `{ptname}' already exists")
-					return
-				end
-				names.add(ptname)
-			end
-
-			# Revolve bound for formal parameter names
-			for i in [0..mclass.arity[ do
-				var nfd = nclassdef.n_formaldefs[i]
-				var nfdt = nfd.n_type
-				if nfdt != null then
-					var bound = resolve_mtype_unchecked(nclassdef, nfdt)
-					if bound == null then return # Forward error
-					if bound.need_anchor then
-						# No F-bounds!
-						error(nfd, "Error: Formal parameter type `{names[i]}' bounded with a formal parameter type")
-					else
-						bounds.add(bound)
-					end
-				else if mclass.mclassdefs.is_empty then
-					# No bound, then implicitely bound by nullable Object
-					bounds.add(objectclass.mclass_type.as_nullable)
-				else
-					# Inherit the bound
-					bounds.add(mclass.intro.bound_mtype.arguments[i])
-				end
-			end
-		end
-
-		var bound_mtype = mclass.get_mtype(bounds)
-		var mclassdef = new MClassDef(mmodule, bound_mtype, nclassdef.location, names)
-		nclassdef.mclassdef = mclassdef
-		self.mclassdef2nclassdef[mclassdef] = nclassdef
-
-		if mclassdef.is_intro then
-			self.toolcontext.info("{mclassdef} introduces new {mclass.kind} {mclass.full_name}", 3)
-		else
-			self.toolcontext.info("{mclassdef} refine {mclass.kind} {mclass.full_name}", 3)
+		# TODO: Correctly check for useless importation
+		# It is even doable?
+		var directs = mmodule.in_importation.direct_greaters
+		for nim in nmodule.n_imports do
+			if not nim isa AStdImport then continue
+			var im = nim.mmodule
+			if im == null then continue
+			if directs.has(im) then continue
+			# This generates so much noise that it is simpler to just comment it
+			#warning(nim, "Warning: possible useless importation of {im}")
 		end
 	end
 
-	# Visit the AST and set the super-types of the MClassdef objects
-	private fun collect_a_mclassdef_inheritance(nmodule: AModule, nclassdef: AClassdef)
-	do
-		var mmodule = nmodule.mmodule.as(not null)
-		var objectclass = try_get_mclass_by_name(nmodule, mmodule, "Object")
-		var mclass = nclassdef.mclass.as(not null)
-		var mclassdef = nclassdef.mclassdef.as(not null)
-
-		var specobject = true
-		var supertypes = new Array[MClassType]
-		if nclassdef isa AStdClassdef then
-			for nsc in nclassdef.n_superclasses do
-				specobject = false
-				var ntype = nsc.n_type
-				var mtype = resolve_mtype_unchecked(nclassdef, ntype)
-				if mtype == null then continue # Skip because of error
-				if not mtype isa MClassType then
-					error(ntype, "Error: supertypes cannot be a formal type")
-					return
-				end
-				supertypes.add mtype
-				#print "new super : {mclass} < {mtype}"
-			end
-		end
-		if specobject and mclass.name != "Object" and objectclass != null and mclassdef.is_intro then
-			supertypes.add objectclass.mclass_type
-		end
-
-		mclassdef.set_supertypes(supertypes)
-		if not supertypes.is_empty then self.toolcontext.info("{mclassdef} new super-types: {supertypes.join(", ")}", 3)
-	end
-
-	# Check the validity of the specialization heirarchy
-	private fun check_supertypes(nmodule: AModule, nclassdef: AClassdef)
-	do
-		var mmodule = nmodule.mmodule.as(not null)
-		var objectclass = try_get_mclass_by_name(nmodule, mmodule, "Object")
-		var mclass = nclassdef.mclass.as(not null)
-		var mclassdef = nclassdef.mclassdef.as(not null)
-
-		for s in mclassdef.supertypes do
-			if s.is_subtype(mmodule, mclassdef.bound_mtype, mclassdef.bound_mtype) then
-				error(nclassdef, "Error: Inheritance loop for class {mclass} with type {s}")
-			end
-		end
-	end
-
-	# Build the classes of the module `nmodule'.
-	# REQUIRE: classes of imported modules are already build. (let `build_all_classes' do the job)
-	private fun build_classes(nmodule: AModule)
-	do
-		# Force building recursively
-		if nmodule.build_classes_is_done then return
-		nmodule.build_classes_is_done = true
-		var mmodule = nmodule.mmodule.as(not null)
-		for imp in mmodule.in_importation.direct_greaters do
-
-			build_classes(mmodule2nmodule[imp])
-		end
-
-		# Create all classes
-		for nclassdef in nmodule.n_classdefs do
-			self.build_a_mclass(nmodule, nclassdef)
-		end
-
-		# Create all classdefs
-		for nclassdef in nmodule.n_classdefs do
-			self.build_a_mclassdef(nmodule, nclassdef)
-		end
-
-		for nclassdef in nmodule.n_classdefs do
-			if nclassdef.mclassdef == null then return # forward error
-		end
-
-		# Create inheritance on all classdefs
-		for nclassdef in nmodule.n_classdefs do
-			self.collect_a_mclassdef_inheritance(nmodule, nclassdef)
-		end
-
-		# Create the mclassdef hierarchy
-		for nclassdef in nmodule.n_classdefs do
-			var mclassdef = nclassdef.mclassdef.as(not null)
-			mclassdef.add_in_hierarchy
-		end
-
-		# Check inheritance
-		for nclassdef in nmodule.n_classdefs do
-			self.check_supertypes(nmodule, nclassdef)
-		end
-
-		# Check unchecked ntypes
-		for nclassdef in nmodule.n_classdefs do
-			if nclassdef isa AStdClassdef then
-				# check bound of formal parameter
-				for nfd in  nclassdef.n_formaldefs do
-					var nfdt = nfd.n_type
-					if nfdt != null and nfdt.mtype != null then
-						var bound = resolve_mtype(nclassdef, nfdt)
-						if bound == null then return # Forward error
-					end
-				end
-				# check declared super types
-				for nsc in nclassdef.n_superclasses do
-					var ntype = nsc.n_type
-					if ntype.mtype != null then
-						var mtype = resolve_mtype(nclassdef, ntype)
-						if mtype == null then return # Forward error
-					end
-				end
-			end
-
-		end
-
-		# TODO: Check that the super-class is not intrusive
-
-		# TODO: Check that the super-class is not already known (by transitivity)
-
-		for nclassdef in nmodule.n_classdefs do
-			self.build_properties(nclassdef)
-		end
-	end
+	# All the loaded modules
+	var nmodules = new Array[AModule]
 
 	# Register the nmodule associated to each mmodule
-	# FIXME: why not refine the MModule class with a nullable attribute?
-	var mmodule2nmodule: HashMap[MModule, AModule] = new HashMap[MModule, AModule]
-	# Register the nclassdef associated to each mclassdef
-	# FIXME: why not refine the MClassDef class with a nullable attribute?
-	var mclassdef2nclassdef: HashMap[MClassDef, AClassdef] = new HashMap[MClassDef, AClassdef]
-	# Register the npropdef associated to each mpropdef
-	# FIXME: why not refine the MPropDef class with a nullable attribute?
-	var mpropdef2npropdef: HashMap[MPropDef, APropdef] = new HashMap[MPropDef, APropdef]
-
-	# Build the properties of `nclassdef'.
-	# REQUIRE: all superclasses are built.
-	private fun build_properties(nclassdef: AClassdef)
-	do
-		# Force building recursively
-		if nclassdef.build_properties_is_done then return
-		nclassdef.build_properties_is_done = true
-		var mclassdef = nclassdef.mclassdef.as(not null)
-		if mclassdef.in_hierarchy == null then return # Skip error
-		for superclassdef in mclassdef.in_hierarchy.direct_greaters do
-			build_properties(mclassdef2nclassdef[superclassdef])
-		end
-
-		for npropdef in nclassdef.n_propdefs do
-			npropdef.build_property(self, nclassdef)
-		end
-		for npropdef in nclassdef.n_propdefs do
-			npropdef.build_signature(self, nclassdef)
-		end
-		for npropdef in nclassdef.n_propdefs do
-			npropdef.check_signature(self, nclassdef)
-		end
-		process_default_constructors(nclassdef)
-	end
-
-	# Introduce or inherit default constructor
-	# This is the last part of `build_properties'.
-	private fun process_default_constructors(nclassdef: AClassdef)
-	do
-		var mclassdef = nclassdef.mclassdef.as(not null)
-
-		# Are we a refinement
-		if not mclassdef.is_intro then return
-
-		# Is the class forbid constructors?
-		if not mclassdef.mclass.kind.need_init then return
-
-		# Is there already a constructor defined?
-		for mpropdef in mclassdef.mpropdefs do
-			if not mpropdef isa MMethodDef then continue
-			if mpropdef.mproperty.is_init then return
-		end
-
-		if not nclassdef isa AStdClassdef then return
-
-		var mmodule = nclassdef.mclassdef.mmodule
-		# Do we inherit for a constructor?
-		var combine = new Array[MMethod]
-		var inhc: nullable MClass = null
-		for st in mclassdef.supertypes do
-			var c = st.mclass
-			if not c.kind.need_init then continue
-			st = st.anchor_to(mmodule, nclassdef.mclassdef.bound_mtype)
-			var candidate = self.try_get_mproperty_by_name2(nclassdef, mmodule, st, "init").as(nullable MMethod)
-			if candidate != null and candidate.intro.msignature.arity == 0 then
-				combine.add(candidate)
-				continue
-			end
-			var inhc2 = c.inherit_init_from
-			if inhc2 == null then inhc2 = c
-			if inhc2 == inhc then continue
-			if inhc != null then
-				self.error(nclassdef, "Error: Cannot provide a defaut constructor: conflict for {inhc} and {c}")
-			else
-				inhc = inhc2
-			end
-		end
-		if combine.is_empty and inhc != null then
-			# TODO: actively inherit the consturctor
-			self.toolcontext.info("{mclassdef} inherits all constructors from {inhc}", 3)
-			mclassdef.mclass.inherit_init_from = inhc
-			return
-		end
-		if not combine.is_empty and inhc != null then
-			self.error(nclassdef, "Error: Cannot provide a defaut constructor: conflict for {combine.join(", ")} and {inhc}")
-			return
-		end
-
-		if not combine.is_empty then
-			nclassdef.super_inits = combine
-			var mprop = new MMethod(mclassdef, "init", mclassdef.mclass.visibility)
-			var mpropdef = new MMethodDef(mclassdef, mprop, nclassdef.location)
-			var mparameters = new Array[MParameter]
-			var msignature = new MSignature(mparameters, null)
-			mpropdef.msignature = msignature
-			mprop.is_init = true
-			nclassdef.mfree_init = mpropdef
-			self.toolcontext.info("{mclassdef} gets a free empty constructor {mpropdef}{msignature}", 3)
-			return
-		end
-
-		# Collect undefined attributes
-		var mparameters = new Array[MParameter]
-		for npropdef in nclassdef.n_propdefs do
-			if npropdef isa AAttrPropdef and npropdef.n_expr == null then
-				if npropdef.mpropdef == null then return # Skip broken attribute
-				var paramname = npropdef.mpropdef.mproperty.name.substring_from(1)
-				var ret_type = npropdef.mpropdef.static_mtype
-				if ret_type == null then return
-				var mparameter = new MParameter(paramname, ret_type, false)
-				mparameters.add(mparameter)
-			end
-		end
-
-		var mprop = new MMethod(mclassdef, "init", mclassdef.mclass.visibility)
-		var mpropdef = new MMethodDef(mclassdef, mprop, nclassdef.location)
-		var msignature = new MSignature(mparameters, null)
-		mpropdef.msignature = msignature
-		mprop.is_init = true
-		nclassdef.mfree_init = mpropdef
-		self.toolcontext.info("{mclassdef} gets a free constructor for attributes {mpropdef}{msignature}", 3)
-	end
-
-	# Return the static type associated to the node `ntype'.
-	# `classdef' is the context where the call is made (used to understand formal types)
-	# The mmodule used as context is `nclassdef.mmodule'
-	# In case of problem, an error is displayed on `ntype' and null is returned.
-	# FIXME: the name "resolve_mtype" is awful
-	fun resolve_mtype_unchecked(nclassdef: AClassdef, ntype: AType): nullable MType
-	do
-		var name = ntype.n_id.text
-		var mclassdef = nclassdef.mclassdef
-		var mmodule = nclassdef.parent.as(AModule).mmodule.as(not null)
-		var res: MType
-
-		# Check virtual type
-		if mclassdef != null then
-			var prop = try_get_mproperty_by_name(ntype, mclassdef, name).as(nullable MVirtualTypeProp)
-			if prop != null then
-				if not ntype.n_types.is_empty then
-					error(ntype, "Type error: formal type {name} cannot have formal parameters.")
-				end
-				res = prop.mvirtualtype
-				if ntype.n_kwnullable != null then res = res.as_nullable
-				ntype.mtype = res
-				return res
-			end
-		end
-
-		# Check parameter type
-		if mclassdef != null and mclassdef.parameter_names.has(name) then
-			if not ntype.n_types.is_empty then
-				error(ntype, "Type error: formal type {name} cannot have formal parameters.")
-			end
-			for i in [0..mclassdef.parameter_names.length[ do
-				if mclassdef.parameter_names[i] == name then
-					res = mclassdef.mclass.mclass_type.arguments[i]
-					if ntype.n_kwnullable != null then res = res.as_nullable
-					ntype.mtype = res
-					return res
-				end
-			end
-			abort
-		end
-
-		# Check class
-		var mclass = try_get_mclass_by_name(ntype, mmodule, name)
-		if mclass != null then
-			var arity = ntype.n_types.length
-			if arity != mclass.arity then
-				if arity == 0 then
-					error(ntype, "Type error: '{name}' is a generic class.")
-				else if mclass.arity == 0 then
-					error(ntype, "Type error: '{name}' is not a generic class.")
-				else
-					error(ntype, "Type error: '{name}' has {mclass.arity} parameters ({arity} are provided).")
-				end
-				return null
-			end
-			if arity == 0 then
-				res = mclass.mclass_type
-				if ntype.n_kwnullable != null then res = res.as_nullable
-				ntype.mtype = res
-				return res
-			else
-				var mtypes = new Array[MType]
-				for nt in ntype.n_types do
-					var mt = resolve_mtype_unchecked(nclassdef, nt)
-					if mt == null then return null # Forward error
-					mtypes.add(mt)
-				end
-				res = mclass.get_mtype(mtypes)
-				if ntype.n_kwnullable != null then res = res.as_nullable
-				ntype.mtype = res
-				return res
-			end
-		end
-
-		# If everything fail, then give up :(
-		error(ntype, "Type error: class {name} not found in module {mmodule}.")
-		return null
-	end
-
-	# Return the static type associated to the node `ntype'.
-	# `classdef' is the context where the call is made (used to understand formal types)
-	# The mmodule used as context is `nclassdef.mmodule'
-	# In case of problem, an error is displayed on `ntype' and null is returned.
-	# FIXME: the name "resolve_mtype" is awful
-	fun resolve_mtype(nclassdef: AClassdef, ntype: AType): nullable MType
-	do
-		var mtype = ntype.mtype
-		if mtype == null then mtype = resolve_mtype_unchecked(nclassdef, ntype)
-		if mtype == null then return null # Forward error
-
-		if ntype.checked_mtype then return mtype
-		if mtype isa MGenericType then
-			var mmodule = nclassdef.parent.as(AModule).mmodule.as(not null)
-			var mclassdef = nclassdef.mclassdef
-			var mclass = mtype.mclass
-			for i in [0..mclass.arity[ do
-				var bound = mclass.intro.bound_mtype.arguments[i]
-				var nt = ntype.n_types[i]
-				var mt = resolve_mtype(nclassdef, nt)
-				if mt == null then return null # forward error
-				if not mt.is_subtype(mmodule, mclassdef.bound_mtype, bound) then
-					error(nt, "Type error: expected {bound}, got {mt}")
-					return null
-				end
-			end
-		end
-		ntype.checked_mtype = true
-		return mtype
-	end
+	# FIXME: why not refine the `MModule` class with a nullable attribute?
+	var mmodule2nmodule = new HashMap[MModule, AModule]
 
 	# Helper function to display an error on a node.
-	# Alias for `self.toolcontext.error(n.hot_location, text)'
+	# Alias for `self.toolcontext.error(n.hot_location, text)`
 	fun error(n: ANode, text: String)
 	do
 		self.toolcontext.error(n.hot_location, text)
 	end
 
 	# Helper function to display a warning on a node.
-	# Alias for: `self.toolcontext.warning(n.hot_location, text)'
-	fun warning(n: ANode, text: String)
+	# Alias for: `self.toolcontext.warning(n.hot_location, text)`
+	fun warning(n: ANode, tag, text: String)
+	do
+		self.toolcontext.warning(n.hot_location, tag, text)
+	end
+
+	# Helper function to display an advice on a node.
+	# Alias for: `self.toolcontext.advice(n.hot_location, text)`
+	fun advice(n: ANode, tag, text: String)
 	do
-		self.toolcontext.warning(n.hot_location, text)
+		self.toolcontext.advice(n.hot_location, tag, text)
 	end
 
-	# Force to get the primitive method named `name' on the type `recv' or do a fatal error on `n'
-	fun force_get_primitive_method(n: ANode, name: String, recv: MType, mmodule: MModule): MMethod
+	# Force to get the primitive method named `name` on the type `recv` or do a fatal error on `n`
+	fun force_get_primitive_method(n: ANode, name: String, recv: MClass, mmodule: MModule): MMethod
 	do
 		var res = mmodule.try_get_primitive_method(name, recv)
 		if res == null then
@@ -916,66 +744,44 @@ class ModelBuilder
 	end
 end
 
-redef class AModule
-	# The associated MModule once build by a `ModelBuilder'
-	var mmodule: nullable MModule
-	# Flag that indicate if the importation is already completed
-	var is_importation_done: Bool = false
-	# Flag that indicate if the class and prop building is already completed
-	var build_classes_is_done: Bool = false
-	# What is the AClassdef associated to a MClass?
-	# Used to check multiple definition of a class.
-	var mclass2nclassdef: Map[MClass, AClassdef] = new HashMap[MClass, AClassdef]
+# placeholder to a module file identified but not always loaded in a project
+private class ModulePath
+	# The name of the module
+	# (it's the basename of the filepath)
+	var name: String
 
-end
+	# The human path of the module
+	var filepath: String
 
-redef class MClass
-	# The class whose self inherit all the constructors.
-	# FIXME: this is needed to implement the crazy constructor mixin thing of the of old compiler. We need to think what to do with since this cannot stay in the modelbuilder
-	var inherit_init_from: nullable MClass = null
-end
+	# The group (and the project) of the possible module
+	var mgroup: MGroup
 
-redef class AClassdef
-	# The associated MClass once build by a `ModelBuilder'
-	var mclass: nullable MClass
-	# The associated MClassDef once build by a `ModelBuilder'
-	var mclassdef: nullable MClassDef
-	var build_properties_is_done: Bool = false
-	# The list of super-constructor to call at the start of the free constructor
-	# FIXME: this is needed to implement the crazy constructor thing of the of old compiler. We need to think what to do with since this cannot stay in the modelbuilder
-	var super_inits: nullable Collection[MMethod] = null
-
-	# The free init (implicitely constructed by the class if required)
-	var mfree_init: nullable MMethodDef = null
-
-	# What is the APropdef associated to a MProperty?
-	# Used to check multiple definition of a property.
-	var mprop2npropdef: Map[MProperty, APropdef] = new HashMap[MProperty, APropdef]
-end
+	# The loaded module (if any)
+	var mmodule: nullable MModule = null
 
-redef class AClasskind
-	# The class kind associated with the AST node class
-	private fun mkind: MClassKind is abstract
-end
-redef class AConcreteClasskind
-	redef fun mkind do return concrete_kind
+	redef fun to_s do return filepath
 end
-redef class AAbstractClasskind
-	redef fun mkind do return abstract_kind
-end
-redef class AInterfaceClasskind
-	redef fun mkind do return interface_kind
+
+redef class MGroup
+	# modules paths associated with the group
+	private var module_paths = new Array[ModulePath]
 end
-redef class AEnumClasskind
-	redef fun mkind do return enum_kind
+
+redef class AStdImport
+	# The imported module once determined
+	var mmodule: nullable MModule = null
 end
-redef class AExternClasskind
-	redef fun mkind do return extern_kind
+
+redef class AModule
+	# The associated MModule once build by a `ModelBuilder`
+	var mmodule: nullable MModule
+	# Flag that indicate if the importation is already completed
+	var is_importation_done: Bool = false
 end
 
 redef class AVisibility
 	# The visibility level associated with the AST node class
-	private fun mvisibility: MVisibility is abstract
+	fun mvisibility: MVisibility is abstract
 end
 redef class AIntrudeVisibility
 	redef fun mvisibility do return intrude_visibility
@@ -990,719 +796,29 @@ redef class APrivateVisibility
 	redef fun mvisibility do return private_visibility
 end
 
-redef class AType
-	# The mtype associated to the node
-	var mtype: nullable MType = null
-
-	# Is the mtype a valid one?
-	var checked_mtype: Bool = false
-end
-
-#
-
-redef class Prod
-	# Join the text of all tokens
-	# Used to get the 'real name' of method definitions.
-	fun collect_text: String
-	do
-		var v = new TextCollectorVisitor
-		v.enter_visit(self)
-		assert v.text != ""
-		return v.text
-	end
-end
-
-private class TextCollectorVisitor
-	super Visitor
-	var text: String = ""
-	redef fun visit(n)
-	do
-		if n isa Token then text += n.text
-		n.visit_all(self)
-	end
-end
-
-redef class APropdef
-	private fun build_property(modelbuilder: ModelBuilder, nclassdef: AClassdef)
-	do
-	end
-	private fun build_signature(modelbuilder: ModelBuilder, nclassdef: AClassdef)
-	do
-	end
-	private fun check_signature(modelbuilder: ModelBuilder, nclassdef: AClassdef)
-	do
-	end
-	private fun new_property_visibility(modelbuilder: ModelBuilder, nclassdef: AClassdef, nvisibility: nullable AVisibility): MVisibility
-	do
-		var mvisibility = public_visibility
-		if nvisibility != null then mvisibility = nvisibility.mvisibility
-		if nclassdef.mclassdef.mclass.visibility == private_visibility then
-			if mvisibility == protected_visibility then
-				assert nvisibility != null
-				modelbuilder.error(nvisibility, "Error: The only legal visibility for properties in a private class is private.")
-			else if mvisibility == private_visibility then
-				assert nvisibility != null
-				# Not yet
-				# modelbuilder.warning(nvisibility, "Warning: private is unrequired since the only legal visibility for properties in a private class is private.")
-			end
-			mvisibility = private_visibility
-		end
-		return mvisibility
-	end
-
-	private fun check_redef_property_visibility(modelbuilder: ModelBuilder, nclassdef: AClassdef, nvisibility: nullable AVisibility, mprop: MProperty)
-	do
-		if nvisibility == null then return
-		var mvisibility = nvisibility.mvisibility
-		if mvisibility != mprop.visibility and mvisibility != public_visibility then
-				modelbuilder.error(nvisibility, "Error: redefinition changed the visibility from a {mprop.visibility} to a {mvisibility}")
-		end
-	end
-
-	private fun check_redef_keyword(modelbuilder: ModelBuilder, nclassdef: AClassdef, kwredef: nullable Token, need_redef: Bool, mprop: MProperty): Bool
-	do
-		if nclassdef.mprop2npropdef.has_key(mprop) then
-			modelbuilder.error(self, "Error: A property {mprop} is already defined in class {nclassdef.mclassdef.mclass}.")
-			return false
-		end
-		if kwredef == null then
-			if need_redef then
-				modelbuilder.error(self, "Redef error: {nclassdef.mclassdef.mclass}::{mprop.name} is an inherited property. To redefine it, add the redef keyword.")
-				return false
-			end
-		else
-			if not need_redef then
-				modelbuilder.error(self, "Error: No property {nclassdef.mclassdef.mclass}::{mprop.name} is inherited. Remove the redef keyword to define a new property.")
-				return false
-			end
-		end
-		return true
-	end
-
-end
-
-redef class ASignature
-	# Is the model builder has correctly visited the signature
-	var is_visited = false
-	# Names of parameters from the AST
-	# REQUIRE: is_visited
-	var param_names = new Array[String]
-	# Types of parameters from the AST
-	# REQUIRE: is_visited
-	var param_types = new Array[MType]
-	# Rank of the vararg (of -1 if none)
-	# REQUIRE: is_visited
-	var vararg_rank: Int = -1
-	# Return type
-	var ret_type: nullable MType = null
-
-	# Visit and fill information about a signature
-	private fun visit_signature(modelbuilder: ModelBuilder, nclassdef: AClassdef): Bool
-	do
-		var param_names = self.param_names
-		var param_types = self.param_types
-		for np in self.n_params do
-			param_names.add(np.n_id.text)
-			var ntype = np.n_type
-			if ntype != null then
-				var mtype = modelbuilder.resolve_mtype(nclassdef, ntype)
-				if mtype == null then return false # Skip error
-				for i in [0..param_names.length-param_types.length[ do
-					param_types.add(mtype)
-				end
-				if np.n_dotdotdot != null then
-					if self.vararg_rank != -1 then
-						modelbuilder.error(np, "Error: {param_names[self.vararg_rank]} is already a vararg")
-						return false
-					else
-						self.vararg_rank = param_names.length - 1
-					end
-				end
-			end
-		end
-		var ntype = self.n_type
-		if ntype != null then
-			self.ret_type = modelbuilder.resolve_mtype(nclassdef, ntype)
-			if self.ret_type == null then return false # Skip errir
-		end
-
-		for nclosure in self.n_closure_decls do
-			if not nclosure.n_signature.visit_signature(modelbuilder, nclassdef) then return false
-		end
-
-		self.is_visited = true
-		return true
-	end
-
-	# Build a visited signature
-	fun build_signature(modelbuilder: ModelBuilder, nclassdef: AClassdef): nullable MSignature
-	do
-		if param_names.length != param_types.length then
-			# Some parameters are typed, other parameters are not typed.
-			modelbuilder.error(self.n_params[param_types.length], "Error: Untyped parameter `{param_names[param_types.length]}'.")
-			return null
-		end
-
-		var mparameters = new Array[MParameter]
-		for i in [0..param_names.length[ do
-			var mparameter = new MParameter(param_names[i], param_types[i], i == vararg_rank)
-			mparameters.add(mparameter)
-		end
-
-		var msignature = new MSignature(mparameters, ret_type)
-		return msignature
-	end
-end
-
-redef class AMethPropdef
-	# The associated MMethodDef once build by a `ModelBuilder'
-	var mpropdef: nullable MMethodDef
-
-	# The associated super init if any
-	var super_init: nullable MMethod
-	redef fun build_property(modelbuilder, nclassdef)
-	do
-		var is_init = self isa AInitPropdef
-		var mclassdef = nclassdef.mclassdef.as(not null)
-		var name: String
-		var amethodid = self.n_methid
-		var name_node: ANode
-		if amethodid == null then
-			if self isa AMainMethPropdef then
-				name = "main"
-				name_node = self
-			else if self isa AConcreteInitPropdef then
-				name = "init"
-				name_node = self.n_kwinit
-			else if self isa AExternInitPropdef then
-				name = "init"
-				name_node = self.n_kwnew
-			else
-				abort
-			end
-		else if amethodid isa AIdMethid then
-			name = amethodid.n_id.text
-			name_node = amethodid
-		else
-			# operator, bracket or assign
-			name = amethodid.collect_text
-			name_node = amethodid
-
-			if name == "-" and self.n_signature.n_params.length == 0 then
-				name = "unary -"
-			end
-		end
-
-		var mprop: nullable MMethod = null
-		if not is_init or n_kwredef != null then mprop = modelbuilder.try_get_mproperty_by_name(name_node, mclassdef, name).as(nullable MMethod)
-		if mprop == null then
-			var mvisibility = new_property_visibility(modelbuilder, nclassdef, self.n_visibility)
-			mprop = new MMethod(mclassdef, name, mvisibility)
-			mprop.is_init = is_init
-			mprop.is_new = self isa AExternInitPropdef
-			if not self.check_redef_keyword(modelbuilder, nclassdef, n_kwredef, false, mprop) then return
-		else
-			if n_kwredef == null then
-				if self isa AMainMethPropdef then
-					# no warning
-				else
-					if not self.check_redef_keyword(modelbuilder, nclassdef, n_kwredef, true, mprop) then return
-				end
-			end
-			check_redef_property_visibility(modelbuilder, nclassdef, self.n_visibility, mprop)
-		end
-		nclassdef.mprop2npropdef[mprop] = self
-
-		var mpropdef = new MMethodDef(mclassdef, mprop, self.location)
-
-		self.mpropdef = mpropdef
-		modelbuilder.mpropdef2npropdef[mpropdef] = self
-		if mpropdef.is_intro then
-			modelbuilder.toolcontext.info("{mpropdef} introduces new method {mprop.full_name}", 3)
-		else
-			modelbuilder.toolcontext.info("{mpropdef} redefines method {mprop.full_name}", 3)
-		end
-	end
-
-	redef fun build_signature(modelbuilder, nclassdef)
-	do
-		var mpropdef = self.mpropdef
-		if mpropdef == null then return # Error thus skiped
-		var mmodule = mpropdef.mclassdef.mmodule
-		var nsig = self.n_signature
-
-		# Retrieve info from the signature AST
-		var param_names = new Array[String] # Names of parameters from the AST
-		var param_types = new Array[MType] # Types of parameters from the AST
-		var vararg_rank = -1
-		var ret_type: nullable MType = null # Return type from the AST
-		if nsig != null then
-			if not nsig.visit_signature(modelbuilder, nclassdef) then return
-			param_names = nsig.param_names
-			param_types = nsig.param_types
-			vararg_rank = nsig.vararg_rank
-			ret_type = nsig.ret_type
-		end
-
-		# Look for some signature to inherit
-		# FIXME: do not inherit from the intro, but from the most specific
-		var msignature: nullable MSignature = null
-		if not mpropdef.is_intro then
-			msignature = mpropdef.mproperty.intro.msignature
-			if msignature == null then return # Skip error
-
-			# Check inherited signature arity
-			if param_names.length != msignature.arity then
-				var node: ANode
-				if nsig != null then node = nsig else node = self
-				modelbuilder.error(node, "Redef error: {mpropdef} redefines {mpropdef.mproperty.intro} with {param_names.length} parameter(s), {msignature.arity} expected. Signature is {mpropdef}{msignature}")
-				return
-			end
-		else if mpropdef.mproperty.is_init then
-			# FIXME UGLY: inherit signature from a super-constructor
-			for msupertype in nclassdef.mclassdef.supertypes do
-				msupertype = msupertype.anchor_to(mmodule, nclassdef.mclassdef.bound_mtype)
-				var candidate = modelbuilder.try_get_mproperty_by_name2(self, mmodule, msupertype, mpropdef.mproperty.name)
-				if candidate != null then
-					if msignature == null then
-						msignature = candidate.intro.as(MMethodDef).msignature
-					end
-				end
-			end
-		end
-
-
-		# Inherit the signature
-		if msignature != null and param_names.length != param_types.length and param_names.length == msignature.arity and param_types.length == 0 then
-			# Parameters are untyped, thus inherit them
-			param_types = new Array[MType]
-			for mparameter in msignature.mparameters do
-				param_types.add(mparameter.mtype)
-			end
-			vararg_rank = msignature.vararg_rank
-		end
-		if msignature != null and ret_type == null then
-			ret_type = msignature.return_mtype
-		end
-
-		if param_names.length != param_types.length then
-			# Some parameters are typed, other parameters are not typed.
-			modelbuilder.error(nsig.n_params[param_types.length], "Error: Untyped parameter `{param_names[param_types.length]}'.")
-			return
-		end
-
-		var mparameters = new Array[MParameter]
-		for i in [0..param_names.length[ do
-			var mparameter = new MParameter(param_names[i], param_types[i], i == vararg_rank)
-			mparameters.add(mparameter)
-		end
-
-		msignature = new MSignature(mparameters, ret_type)
-		mpropdef.msignature = msignature
-
-		if nsig != null then
-			for nclosure in nsig.n_closure_decls do
-				var clos_signature = nclosure.n_signature.build_signature(modelbuilder, nclassdef)
-				if clos_signature == null then return
-				var mparameter = new MParameter(nclosure.n_id.text, clos_signature, false)
-				msignature.mclosures.add(mparameter)
-			end
-		end
-
-	end
-
-	redef fun check_signature(modelbuilder, nclassdef)
-	do
-		var mpropdef = self.mpropdef
-		if mpropdef == null then return # Error thus skiped
-		var mmodule = mpropdef.mclassdef.mmodule
-		var nsig = self.n_signature
-		var mysignature = self.mpropdef.msignature
-		if mysignature == null then return # Error thus skiped
-
-		# Lookup for signature in the precursor
-		# FIXME all precursors should be considered
-		if not mpropdef.is_intro then
-			var msignature = mpropdef.mproperty.intro.msignature
-			if msignature == null then return
-
-			var precursor_ret_type = msignature.return_mtype
-			var ret_type = mysignature.return_mtype
-			if ret_type != null and precursor_ret_type == null then
-				modelbuilder.error(nsig.n_type.as(not null), "Redef Error: {mpropdef.mproperty} is a procedure, not a function.")
-				return
-			end
-
-			if mysignature.arity > 0 then
-				# Check parameters types
-				for i in [0..mysignature.arity[ do
-					var myt = mysignature.mparameters[i].mtype
-					var prt = msignature.mparameters[i].mtype
-					if not myt.is_subtype(mmodule, nclassdef.mclassdef.bound_mtype, prt) and
-							not prt.is_subtype(mmodule, nclassdef.mclassdef.bound_mtype, myt) then
-						modelbuilder.error(nsig.n_params[i], "Redef Error: Wrong type for parameter `{mysignature.mparameters[i].name}'. found {myt}, expected {prt}.")
-					end
-				end
-			end
-			if precursor_ret_type != null then
-				if ret_type == null then
-					# Inherit the return type
-					ret_type = precursor_ret_type
-				else if not ret_type.is_subtype(mmodule, nclassdef.mclassdef.bound_mtype, precursor_ret_type) then
-					modelbuilder.error(nsig.n_type.as(not null), "Redef Error: Wrong return type. found {ret_type}, expected {precursor_ret_type}.")
-				end
-			end
-		end
-	end
-end
-
-redef class AAttrPropdef
-	# The associated MAttributeDef once build by a `ModelBuilder'
-	var mpropdef: nullable MAttributeDef
-	# The associated getter (read accessor) if any
-	var mreadpropdef: nullable MMethodDef
-	# The associated setter (write accessor) if any
-	var mwritepropdef: nullable MMethodDef
-	redef fun build_property(modelbuilder, nclassdef)
-	do
-		var mclassdef = nclassdef.mclassdef.as(not null)
-		var mclass = mclassdef.mclass
-
-		var name: String
-		if self.n_id != null then
-			name = self.n_id.text
-		else
-			name = self.n_id2.text
-		end
-
-		if mclass.kind == interface_kind or mclassdef.mclass.kind == enum_kind then
-			modelbuilder.error(self, "Error: Attempt to define attribute {name} in the interface {mclass}.")
-		else if mclass.kind == enum_kind then
-			modelbuilder.error(self, "Error: Attempt to define attribute {name} in the enum class {mclass}.")
-		else if mclass.kind == extern_kind then
-			modelbuilder.error(self, "Error: Attempt to define attribute {name} in the extern class {mclass}.")
-		end
-
-		var nid = self.n_id
-		if nid != null then
-			# Old attribute style
-			var mprop = modelbuilder.try_get_mproperty_by_name(nid, mclassdef, name)
-			if mprop == null then
-				var mvisibility = new_property_visibility(modelbuilder, nclassdef, self.n_visibility)
-				mprop = new MAttribute(mclassdef, name, mvisibility)
-				if not self.check_redef_keyword(modelbuilder, nclassdef, self.n_kwredef, false, mprop) then return
-			else
-				assert mprop isa MAttribute
-				check_redef_property_visibility(modelbuilder, nclassdef, self.n_visibility, mprop)
-				if not self.check_redef_keyword(modelbuilder, nclassdef, self.n_kwredef, true, mprop) then return
-			end
-			nclassdef.mprop2npropdef[mprop] = self
-
-			var mpropdef = new MAttributeDef(mclassdef, mprop, self.location)
-			self.mpropdef = mpropdef
-			modelbuilder.mpropdef2npropdef[mpropdef] = self
-
-			var nreadable = self.n_readable
-			if nreadable != null then
-				var readname = name.substring_from(1)
-				var mreadprop = modelbuilder.try_get_mproperty_by_name(nid, mclassdef, readname).as(nullable MMethod)
-				if mreadprop == null then
-					var mvisibility = new_property_visibility(modelbuilder, nclassdef, nreadable.n_visibility)
-					mreadprop = new MMethod(mclassdef, readname, mvisibility)
-					if not self.check_redef_keyword(modelbuilder, nclassdef, nreadable.n_kwredef, false, mreadprop) then return
-				else
-					if not self.check_redef_keyword(modelbuilder, nclassdef, nreadable.n_kwredef, true, mreadprop) then return
-					check_redef_property_visibility(modelbuilder, nclassdef, nreadable.n_visibility, mreadprop)
-				end
-				nclassdef.mprop2npropdef[mreadprop] = self
-
-				var mreadpropdef = new MMethodDef(mclassdef, mreadprop, self.location)
-				self.mreadpropdef = mreadpropdef
-				modelbuilder.mpropdef2npropdef[mreadpropdef] = self
-			end
-
-			var nwritable = self.n_writable
-			if nwritable != null then
-				var writename = name.substring_from(1) + "="
-				var mwriteprop = modelbuilder.try_get_mproperty_by_name(nid, mclassdef, writename).as(nullable MMethod)
-				if mwriteprop == null then
-					var mvisibility = new_property_visibility(modelbuilder, nclassdef, nwritable.n_visibility)
-					mwriteprop = new MMethod(mclassdef, writename, mvisibility)
-					if not self.check_redef_keyword(modelbuilder, nclassdef, nwritable.n_kwredef, false, mwriteprop) then return
-				else
-					if not self.check_redef_keyword(modelbuilder, nclassdef, nwritable.n_kwredef, true, mwriteprop) then return
-					check_redef_property_visibility(modelbuilder, nclassdef, nwritable.n_visibility, mwriteprop)
-				end
-				nclassdef.mprop2npropdef[mwriteprop] = self
-
-				var mwritepropdef = new MMethodDef(mclassdef, mwriteprop, self.location)
-				self.mwritepropdef = mwritepropdef
-				modelbuilder.mpropdef2npropdef[mwritepropdef] = self
-			end
-		else
-			# New attribute style
-			var nid2 = self.n_id2.as(not null)
-			var mprop = new MAttribute(mclassdef, "@" + name, none_visibility)
-			var mpropdef = new MAttributeDef(mclassdef, mprop, self.location)
-			self.mpropdef = mpropdef
-			modelbuilder.mpropdef2npropdef[mpropdef] = self
-
-			var readname = name
-			var mreadprop = modelbuilder.try_get_mproperty_by_name(nid2, mclassdef, readname).as(nullable MMethod)
-			if mreadprop == null then
-				var mvisibility = new_property_visibility(modelbuilder, nclassdef, self.n_visibility)
-				mreadprop = new MMethod(mclassdef, readname, mvisibility)
-				if not self.check_redef_keyword(modelbuilder, nclassdef, n_kwredef, false, mreadprop) then return
-			else
-				if not self.check_redef_keyword(modelbuilder, nclassdef, n_kwredef, true, mreadprop) then return
-				check_redef_property_visibility(modelbuilder, nclassdef, self.n_visibility, mreadprop)
-			end
-			nclassdef.mprop2npropdef[mreadprop] = self
-
-			var mreadpropdef = new MMethodDef(mclassdef, mreadprop, self.location)
-			self.mreadpropdef = mreadpropdef
-			modelbuilder.mpropdef2npropdef[mreadpropdef] = self
-
-			var writename = name + "="
-			var nwritable = self.n_writable
-			var mwriteprop = modelbuilder.try_get_mproperty_by_name(nid2, mclassdef, writename).as(nullable MMethod)
-			var nwkwredef: nullable Token = null
-			if nwritable != null then nwkwredef = nwritable.n_kwredef
-			if mwriteprop == null then
-				var mvisibility
-				if nwritable != null then
-					mvisibility = new_property_visibility(modelbuilder, nclassdef, nwritable.n_visibility)
-				else
-					mvisibility = private_visibility
-				end
-				mwriteprop = new MMethod(mclassdef, writename, mvisibility)
-				if not self.check_redef_keyword(modelbuilder, nclassdef, nwkwredef, false, mwriteprop) then return
-			else
-				if not self.check_redef_keyword(modelbuilder, nclassdef, nwkwredef, true, mwriteprop) then return
-				if nwritable != null then
-					check_redef_property_visibility(modelbuilder, nclassdef, nwritable.n_visibility, mwriteprop)
-				end
-			end
-			nclassdef.mprop2npropdef[mwriteprop] = self
-
-			var mwritepropdef = new MMethodDef(mclassdef, mwriteprop, self.location)
-			self.mwritepropdef = mwritepropdef
-			modelbuilder.mpropdef2npropdef[mwritepropdef] = self
-		end
-	end
-
-	redef fun build_signature(modelbuilder, nclassdef)
-	do
-		var mpropdef = self.mpropdef
-		if mpropdef == null then return # Error thus skiped
-		var mmodule = mpropdef.mclassdef.mmodule
-		var mtype: nullable MType = null
-
-		var ntype = self.n_type
-		if ntype != null then
-			mtype = modelbuilder.resolve_mtype(nclassdef, ntype)
-			if mtype == null then return
-		end
-
-		if mtype == null then
-			var nexpr = self.n_expr
-			if nexpr != null then
-				if nexpr isa ANewExpr then
-					mtype = modelbuilder.resolve_mtype(nclassdef, nexpr.n_type)
-				else if nexpr isa AIntExpr then
-					var cla = modelbuilder.try_get_mclass_by_name(nexpr, mmodule, "Int")
-					if cla != null then mtype = cla.mclass_type
-				else if nexpr isa AFloatExpr then
-					var cla = modelbuilder.try_get_mclass_by_name(nexpr, mmodule, "Float")
-					if cla != null then mtype = cla.mclass_type
-				else if nexpr isa ACharExpr then
-					var cla = modelbuilder.try_get_mclass_by_name(nexpr, mmodule, "Char")
-					if cla != null then mtype = cla.mclass_type
-				else if nexpr isa ABoolExpr then
-					var cla = modelbuilder.try_get_mclass_by_name(nexpr, mmodule, "Bool")
-					if cla != null then mtype = cla.mclass_type
-				else if nexpr isa ASuperstringExpr then
-					var cla = modelbuilder.try_get_mclass_by_name(nexpr, mmodule, "String")
-					if cla != null then mtype = cla.mclass_type
-				else if nexpr isa AStringFormExpr then
-					var cla = modelbuilder.try_get_mclass_by_name(nexpr, mmodule, "String")
-					if cla != null then mtype = cla.mclass_type
-				else
-					modelbuilder.error(self, "Error: Untyped attribute {mpropdef}. Implicit typing allowed only for literals and new.")
-				end
-
-			else
-				modelbuilder.error(self, "Error: Untyped attribute {mpropdef}")
+redef class ADoc
+	private var mdoc_cache: nullable MDoc
+	fun to_mdoc: MDoc
+	do
+		var res = mdoc_cache
+		if res != null then return res
+		res = new MDoc
+		for c in n_comment do
+			var text = c.text
+			if text.length < 2 then
+				res.content.add ""
+				continue
 			end
-		end
-
-		if mtype == null then return
-
-		mpropdef.static_mtype = mtype
-
-		var mreadpropdef = self.mreadpropdef
-		if mreadpropdef != null then
-			var msignature = new MSignature(new Array[MParameter], mtype)
-			mreadpropdef.msignature = msignature
-		end
-
-		var msritepropdef = self.mwritepropdef
-		if mwritepropdef != null then
-			var name: String
-			if n_id != null then
-				name = n_id.text.substring_from(1)
+			assert text.chars[0] == '#'
+			if text.chars[1] == ' ' then
+				text = text.substring_from(2) # eat starting `#` and space
 			else
-				name = n_id2.text
-			end
-			var mparameter = new MParameter(name, mtype, false)
-			var msignature = new MSignature([mparameter], null)
-			mwritepropdef.msignature = msignature
-		end
-	end
-
-	redef fun check_signature(modelbuilder, nclassdef)
-	do
-		var mpropdef = self.mpropdef
-		if mpropdef == null then return # Error thus skiped
-		var mmodule = mpropdef.mclassdef.mmodule
-		var ntype = self.n_type
-		var mtype = self.mpropdef.static_mtype
-		if mtype == null then return # Error thus skiped
-
-		# Lookup for signature in the precursor
-		# FIXME all precursors should be considered
-		if not mpropdef.is_intro then
-			var precursor_type = mpropdef.mproperty.intro.static_mtype
-			if precursor_type == null then return
-
-			if mtype != precursor_type then
-				modelbuilder.error(ntype.as(not null), "Redef Error: Wrong static type. found {mtype}, expected {precursor_type}.")
-				return
+				text = text.substring_from(1) # eat atarting `#` only
 			end
+			if text.chars.last == '\n' then text = text.substring(0, text.length-1) # drop \n
+			res.content.add(text)
 		end
-
-		# Check getter and setter
-		var meth = self.mreadpropdef
-		if meth != null then self.check_method_signature(modelbuilder, nclassdef, meth)
-		meth = self.mwritepropdef
-		if meth != null then self.check_method_signature(modelbuilder, nclassdef, meth)
-	end
-
-	private fun check_method_signature(modelbuilder: ModelBuilder, nclassdef: AClassdef, mpropdef: MMethodDef)
-	do
-		var mmodule = mpropdef.mclassdef.mmodule
-		var nsig = self.n_type
-		var mysignature = mpropdef.msignature
-		if mysignature == null then return # Error thus skiped
-
-		# Lookup for signature in the precursor
-		# FIXME all precursors should be considered
-		if not mpropdef.is_intro then
-			var msignature = mpropdef.mproperty.intro.msignature
-			if msignature == null then return
-
-			if mysignature.arity != msignature.arity then
-				var node: ANode
-				if nsig != null then node = nsig else node = self
-				modelbuilder.error(node, "Redef Error: {mysignature.arity} parameters found, {msignature.arity} expected. Signature is {mpropdef}{msignature}")
-				return
-			end
-			var precursor_ret_type = msignature.return_mtype
-			var ret_type = mysignature.return_mtype
-			if ret_type != null and precursor_ret_type == null then
-				var node: ANode
-				if nsig != null then node = nsig else node = self
-				modelbuilder.error(node, "Redef Error: {mpropdef.mproperty} is a procedure, not a function.")
-				return
-			end
-
-			if mysignature.arity > 0 then
-				# Check parameters types
-				for i in [0..mysignature.arity[ do
-					var myt = mysignature.mparameters[i].mtype
-					var prt = msignature.mparameters[i].mtype
-					if not myt.is_subtype(mmodule, nclassdef.mclassdef.bound_mtype, prt) and
-							not prt.is_subtype(mmodule, nclassdef.mclassdef.bound_mtype, myt) then
-						var node: ANode
-						if nsig != null then node = nsig else node = self
-						modelbuilder.error(node, "Redef Error: Wrong type for parameter `{mysignature.mparameters[i].name}'. found {myt}, expected {prt}.")
-					end
-				end
-			end
-			if precursor_ret_type != null then
-				if ret_type == null then
-					# Inherit the return type
-					ret_type = precursor_ret_type
-				else if not ret_type.is_subtype(mmodule, nclassdef.mclassdef.bound_mtype, precursor_ret_type) then
-					var node: ANode
-					if nsig != null then node = nsig else node = self
-					modelbuilder.error(node, "Redef Error: Wrong return type. found {ret_type}, expected {precursor_ret_type}.")
-				end
-			end
-		end
-	end
-end
-
-redef class ATypePropdef
-	# The associated MVirtualTypeDef once build by a `ModelBuilder'
-	var mpropdef: nullable MVirtualTypeDef
-	redef fun build_property(modelbuilder, nclassdef)
-	do
-		var mclassdef = nclassdef.mclassdef.as(not null)
-		var name = self.n_id.text
-		var mprop = modelbuilder.try_get_mproperty_by_name(self.n_id, mclassdef, name)
-		if mprop == null then
-			var mvisibility = new_property_visibility(modelbuilder, nclassdef, self.n_visibility)
-			mprop = new MVirtualTypeProp(mclassdef, name, mvisibility)
-			if not self.check_redef_keyword(modelbuilder, nclassdef, self.n_kwredef, false, mprop) then return
-		else
-			if not self.check_redef_keyword(modelbuilder, nclassdef, self.n_kwredef, true, mprop) then return
-			assert mprop isa MVirtualTypeProp
-			check_redef_property_visibility(modelbuilder, nclassdef, self.n_visibility, mprop)
-		end
-		nclassdef.mprop2npropdef[mprop] = self
-
-		var mpropdef = new MVirtualTypeDef(mclassdef, mprop, self.location)
-		self.mpropdef = mpropdef
-	end
-
-	redef fun build_signature(modelbuilder, nclassdef)
-	do
-		var mpropdef = self.mpropdef
-		if mpropdef == null then return # Error thus skiped
-		var mmodule = mpropdef.mclassdef.mmodule
-		var mtype: nullable MType = null
-
-		var ntype = self.n_type
-		mtype = modelbuilder.resolve_mtype(nclassdef, ntype)
-		if mtype == null then return
-
-		mpropdef.bound = mtype
-		# print "{mpropdef}: {mtype}"
-	end
-
-	redef fun check_signature(modelbuilder, nclassdef)
-	do
-		var bound = self.mpropdef.bound
-
-		# Fast case: the bound is not a formal type
-		if not bound isa MVirtualType then return
-
-		var mmodule = nclassdef.mclassdef.mmodule
-		var anchor = nclassdef.mclassdef.bound_mtype
-
-		# Slow case: progress on each resolution until: (i) we loop, or (ii) we found a non formal type
-		var seen = [self.mpropdef.mproperty.mvirtualtype]
-		loop
-			if seen.has(bound) then
-				seen.add(bound)
-				modelbuilder.error(self, "Error: circularity of virtual type definition: {seen.join(" -> ")}")
-				return
-			end
-			seen.add(bound)
-			var next = bound.lookup_bound(mmodule, anchor)
-			if not next isa MVirtualType then return
-			bound = next
-		end
+		mdoc_cache = res
+		return res
 	end
 end