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

diff --git a/src/loader.nit b/src/loader.nit
index 6d7bbe7..169d52e 100644
--- a/src/loader.nit
+++ b/src/loader.nit
@@ -15,20 +15,41 @@
 # limitations under the License.
 
 # Loading of Nit source files
+#
+# The loader takes care of looking for module and projects in the file system, and the associated case of errors.
+# The loading requires several steps:
+#
+# Identify: create an empty model entity associated to a name or a file path.
+# Identification is used for instance when names are given in the command line.
+# See `identify_module` and `identify_group`.
+#
+# Scan: visit directories and identify their contents.
+# Scanning is done to enable the searching of modules in projects.
+# See `scan_group` and `scan_full`.
+#
+# Parse: load the AST and associate it with the model entity.
+# See `MModule::parse`.
+#
+# Import: means recursively load modules imported by a module.
+# See `build_module_importation`.
+#
+# Load: means doing the full sequence: identify, parse and import.
+# See `ModelBuilder::parse`, `ModelBuilder::parse_full`, `MModule::load` `ModelBuilder::load_module.
 module loader
 
 import modelbuilder_base
 import ini
+import nitpm_shared
 
 redef class ToolContext
 	# Option --path
-	var opt_path = new OptionArray("Set include path for loaders (may be used more than once)", "-I", "--path")
+	var opt_path = new OptionArray("Add an additional include path (may be used more than once)", "-I", "--path")
 
 	# Option --only-metamodel
 	var opt_only_metamodel = new OptionBool("Stop after meta-model processing", "--only-metamodel")
 
 	# Option --only-parse
-	var opt_only_parse = new OptionBool("Only proceed to parse step of loaders", "--only-parse")
+	var opt_only_parse = new OptionBool("Only proceed to parse files", "--only-parse")
 
 	redef init
 	do
@@ -45,16 +66,23 @@ redef class ModelBuilder
 		# Setup the paths value
 		paths.append(toolcontext.opt_path.value)
 
+		# Packages managed by nitpm, only use when not testing with tests.sh
+		if "NIT_TESTING_TESTS_SH".environ != "true" then
+			paths.add nitpm_lib_dir
+		end
+
 		var path_env = "NIT_PATH".environ
 		if not path_env.is_empty then
 			paths.append(path_env.split_with(':'))
 		end
 
 		var nit_dir = toolcontext.nit_dir
-		var libname = nit_dir/"lib"
-		if libname.file_exists then paths.add(libname)
-		libname = nit_dir/"contrib"
-		if libname.file_exists then paths.add(libname)
+		if nit_dir != null then
+			var libname = nit_dir/"lib"
+			if libname.file_exists then paths.add(libname)
+			libname = nit_dir/"contrib"
+			if libname.file_exists then paths.add(libname)
+		end
 	end
 
 	# Load a bunch of modules.
@@ -73,8 +101,6 @@ redef class ModelBuilder
 		for a in modules do
 			var nmodule = self.load_module(a)
 			if nmodule == null then continue # Skip error
-			# Load imported module
-			build_module_importation(nmodule)
 			var mmodule = nmodule.mmodule
 			if mmodule == null then continue # skip error
 			mmodules.add mmodule
@@ -86,58 +112,24 @@ redef class ModelBuilder
 
 		if toolcontext.opt_only_parse.value then
 			self.toolcontext.info("*** ONLY PARSE...", 1)
-			exit(0)
+			self.toolcontext.quit
 		end
 
 		return mmodules.to_a
 	end
 
-	# Load recursively all modules of the group `mgroup`.
-	# See `parse` for details.
-	fun parse_group(mgroup: MGroup): Array[MModule]
-	do
-		var res = new Array[MModule]
-		scan_group(mgroup)
-		for mg in mgroup.in_nesting.smallers do
-			for mp in mg.module_paths do
-				var nmodule = self.load_module(mp.filepath)
-				if nmodule == null then continue # Skip error
-				# Load imported module
-				build_module_importation(nmodule)
-				var mmodule = nmodule.mmodule
-				if mmodule == null then continue # Skip error
-				res.add mmodule
-			end
-		end
-		return res
-	end
-
-	# Load a bunch of modules and groups.
-	#
-	# Each name can be:
-	#
-	# * a path to a module, a group or a directory of projects.
-	# * a short name of a module or a group that are looked in the `paths` (-I)
-	#
-	# Then, for each entry, if it is:
-	#
-	# * a module, then is it parser and returned.
-	# * a group then recursively all its modules are parsed.
-	# * a directory of projects then all the modules of all projects are parsed.
-	# * else an error is displayed.
+	# Identify a bunch of modules and groups.
 	#
-	# See `parse` for details.
-	fun parse_full(names: Sequence[String]): Array[MModule]
+	# This does the same as `parse_full` but does only the identification (cf. `identify_module`)
+	fun scan_full(names: Sequence[String]): Array[MModule]
 	do
-		var time0 = get_time
-		# Parse and recursively load
-		self.toolcontext.info("*** PARSE ***", 1)
-		var mmodules = new ArraySet[MModule]
+		var mmodules = new Array[MModule]
 		for a in names do
-			# Case of a group
-			var mgroup = self.get_mgroup(a)
+			# Case of a group (root or sub-directory)
+			var mgroup = self.identify_group(a)
 			if mgroup != null then
-				mmodules.add_all parse_group(mgroup)
+				scan_group(mgroup)
+				for mg in mgroup.in_nesting.smallers do mmodules.add_all mg.mmodules
 				continue
 			end
 
@@ -146,21 +138,19 @@ redef class ModelBuilder
 			if stat != null and stat.is_dir then
 				self.toolcontext.info("look in directory {a}", 2)
 				var fs = a.files
+				alpha_comparator.sort(fs)
 				# Try each entry as a group or a module
 				for f in fs do
+					if f.first == '.' then continue
 					var af = a/f
-					mgroup = get_mgroup(af)
+					mgroup = identify_group(af)
 					if mgroup != null then
-						mmodules.add_all parse_group(mgroup)
+						scan_group(mgroup)
+						for mg in mgroup.in_nesting.smallers do mmodules.add_all mg.mmodules
 						continue
 					end
-					var mp = identify_file(af)
-					if mp != null then
-						var nmodule = self.load_module(af)
-						if nmodule == null then continue # Skip error
-						build_module_importation(nmodule)
-						var mmodule = nmodule.mmodule
-						if mmodule == null then continue # Skip error
+					var mmodule = identify_module(af)
+					if mmodule != null then
 						mmodules.add mmodule
 					else
 						self.toolcontext.info("ignore file {af}", 2)
@@ -169,12 +159,49 @@ redef class ModelBuilder
 				continue
 			end
 
-			var nmodule = self.load_module(a)
-			if nmodule == null then continue # Skip error
-			# Load imported module
-			build_module_importation(nmodule)
-			var mmodule = nmodule.mmodule
-			if mmodule == null then continue # Skip error
+			var mmodule = identify_module(a)
+			if mmodule == null then
+				var le = last_loader_error
+				if le != null then
+					toolcontext.error(null, le)
+				else if a.file_exists then
+					toolcontext.error(null, "Error: `{a}` is not a Nit source file.")
+				else
+					toolcontext.error(null, "Error: cannot find module `{a}`.")
+				end
+				continue
+			end
+
+			mmodules.add mmodule
+		end
+		return mmodules
+	end
+
+	# Load a bunch of modules and groups.
+	#
+	# Each name can be:
+	#
+	# * a path to a module, a group or a directory of packages.
+	# * a short name of a module or a group that are looked in the `paths` (-I)
+	#
+	# Then, for each entry, if it is:
+	#
+	# * a module, then is it parsed and returned.
+	# * a group then recursively all its modules are parsed.
+	# * a directory of packages then all the modules of all packages are parsed.
+	# * else an error is displayed.
+	#
+	# See `parse` for details.
+	fun parse_full(names: Sequence[String]): Array[MModule]
+	do
+		var time0 = get_time
+		# Parse and recursively load
+		self.toolcontext.info("*** PARSE ***", 1)
+		var mmodules = new ArraySet[MModule]
+		var scans = scan_full(names)
+		for mmodule in scans do
+			var ast = mmodule.load(self)
+			if ast == null then continue # Skip error
 			mmodules.add mmodule
 		end
 		var time1 = get_time
@@ -184,7 +211,7 @@ redef class ModelBuilder
 
 		if toolcontext.opt_only_parse.value then
 			self.toolcontext.info("*** ONLY PARSE...", 1)
-			exit(0)
+			self.toolcontext.quit
 		end
 
 		return mmodules.to_a
@@ -199,26 +226,26 @@ redef class ModelBuilder
 	# Path can be added (or removed) by the client
 	var paths = new Array[String]
 
-	# Like (and used by) `get_mmodule_by_name` but just return the ModulePath
-	fun search_mmodule_by_name(anode: nullable ANode, mgroup: nullable MGroup, name: String): nullable ModulePath
+	# Like (and used by) `get_mmodule_by_name` but does not force the parsing of the MModule (cf. `identify_module`)
+	fun search_mmodule_by_name(anode: nullable ANode, mgroup: nullable MGroup, name: String): nullable MModule
 	do
 		# First, look in groups
 		var c = mgroup
 		if c != null then
-			var r = c.mproject.root
+			var r = c.mpackage.root
 			assert r != null
 			scan_group(r)
-			var res = r.mmodule_paths_by_name(name)
+			var res = r.mmodules_by_name(name)
 			if res.not_empty then return res.first
 		end
 
 		# Look at some known directories
 		var lookpaths = self.paths
 
-		# Look in the directory of the group project also (even if not explicitly in the path)
+		# Look in the directory of the group package also (even if not explicitly in the path)
 		if mgroup != null then
 			# path of the root group
-			var dirname = mgroup.mproject.root.filepath
+			var dirname = mgroup.mpackage.root.filepath
 			if dirname != null then
 				dirname = dirname.join_path("..").simplify_path
 				if not lookpaths.has(dirname) and dirname.file_exists then
@@ -228,7 +255,14 @@ redef class ModelBuilder
 			end
 		end
 
-		var candidate = search_module_in_paths(anode.hot_location, name, lookpaths)
+		if mgroup != null then
+			var alias = mgroup.mpackage.import_alias(name)
+			if alias != null then name = alias
+		end
+
+		var loc = null
+		if anode != null then loc = anode.hot_location
+		var candidate = search_module_in_paths(loc, name, lookpaths)
 
 		if candidate == null then
 			if mgroup != null then
@@ -247,42 +281,37 @@ redef class ModelBuilder
 	# 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: nullable 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
-		return load_module_path(path)
-	end
-
-	# Load and process importation of a given ModulePath.
-	#
-	# Basically chains `load_module` and `build_module_importation`.
-	fun load_module_path(path: ModulePath): nullable MModule
-	do
-		var res = self.load_module(path.filepath)
-		if res == null then return null # Forward error
-		# Load imported module
-		build_module_importation(res)
-		return res.mmodule
+		var mmodule = search_mmodule_by_name(anode, mgroup, name)
+		if mmodule == null then return null # Forward error
+		var ast = mmodule.load(self)
+		if ast == null then return null # Forward error
+		return mmodule
 	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
+	# If found, the module is returned.
+	private fun search_module_in_paths(location: nullable Location, name: String, lookpaths: Collection[String]): nullable MModule
 	do
-		var res = new ArraySet[ModulePath]
+		var name_no_version
+		if name.has('=') then
+			name_no_version = name.split('=').first
+		else name_no_version = name
+
+		var res = new ArraySet[MModule]
 		for dirname in lookpaths do
 			# Try a single module file
-			var mp = identify_file((dirname/"{name}.nit").simplify_path)
+			var mp = identify_module((dirname/"{name}.nit").simplify_path)
 			if mp != null then res.add mp
 			# Try the default module of a group
-			var g = get_mgroup((dirname/name).simplify_path)
+			var g = identify_group((dirname/name).simplify_path)
 			if g != null then
 				scan_group(g)
-				res.add_all g.mmodule_paths_by_name(name)
+				res.add_all g.mmodules_by_name(name_no_version)
 			end
 		end
 		if res.is_empty then return null
 		if res.length > 1 then
-			toolcontext.error(location, "Error: conflicting module files for `{name}`: `{res.join(",")}`")
+			toolcontext.error(location, "Error: conflicting module files for `{name}`: `{[for x in res do x.filepath or else x.full_name].join("`, `")}`")
 		end
 		return res.first
 	end
@@ -293,7 +322,7 @@ redef class ModelBuilder
 		var res = new ArraySet[MGroup]
 		for dirname in lookpaths do
 			# try a single group directory
-			var mg = get_mgroup(dirname/name)
+			var mg = identify_group(dirname/name)
 			if mg != null then
 				res.add mg
 			end
@@ -301,29 +330,50 @@ redef class ModelBuilder
 		return res
 	end
 
-	# Cache for `identify_file` by realpath
-	private var identified_files_by_path = new HashMap[String, nullable ModulePath]
+	# Cache for `identify_module` by relative and real paths
+	private var identified_modules_by_path = new HashMap[String, nullable MModule]
 
 	# All the currently identified modules.
-	# See `identify_file`.
-	var identified_files = new Array[ModulePath]
+	# See `identify_module`.
+	#
+	# An identified module exists in the model but might be not yet parsed (no AST), or not yet analysed (no importation).
+	var identified_modules = new Array[MModule]
+
+	# All the currently parsed modules.
+	#
+	# A parsed module exists in the model but might be not yet analysed (no importation).
+	var parsed_modules = new Array[MModule]
+
+	# Some `loader` services are silent and return `null` on error.
+	#
+	# Those services can set `last_loader_error` to precise an specific error message.
+	# if `last_loader_error == null` then a generic error message can be used.
+	#
+	# See `identified_modules` and `identify_group` for details.
+	var last_loader_error: nullable String = null
 
-	# Identify a source file and load the associated project and groups if required.
+	# Identify a source file and load the associated package and groups if required.
 	#
 	# This method does what the user expects when giving an argument to a Nit tool.
 	#
 	# * If `path` is an existing Nit source file (with the `.nit` extension),
-	#   then the associated ModulePath is returned
+	#   then the associated MModule is returned
 	# * If `path` is a directory (with a `/`),
-	#   then the ModulePath of its default module is returned (if any)
+	#   then the MModule of its default module is returned (if any)
 	# * If `path` is a simple identifier (eg. `digraph`),
-	#   then the main module of the project `digraph` is searched in `paths` and returned.
+	#   then the main module of the package `digraph` is searched in `paths` and returned.
 	#
 	# Silently return `null` if `path` does not exists or cannot be identified.
-	fun identify_file(path: String): nullable ModulePath
+	# If `null` is returned, `last_loader_error` can be set to a specific error message.
+	#
+	# On success, it returns a module that is possibly not yet parsed (no AST), or not yet analysed (no importation).
+	# If the module was already identified, or loaded, it is returned.
+	fun identify_module(path: String): nullable MModule
 	do
+		last_loader_error = null
+
 		# special case for not a nit file
-		if path.file_extension != "nit" then
+		if not path.has_suffix(".nit") then do
 			# search dirless files in known -I paths
 			if not path.chars.has('/') then
 				var res = search_module_in_paths(null, path, self.paths)
@@ -331,19 +381,66 @@ redef class ModelBuilder
 			end
 
 			# Found nothing? maybe it is a group...
-			var candidate = null
 			if path.file_exists then
-				var mgroup = get_mgroup(path)
+				var mgroup = identify_group(path)
 				if mgroup != null then
 					var owner_path = mgroup.filepath.join_path(mgroup.name + ".nit")
-					if owner_path.file_exists then candidate = owner_path
+					if owner_path.file_exists then
+						path = owner_path
+						break
+					end
 				end
 			end
 
-			if candidate == null then
-				return null
+			# Found nothing? maybe it is a qualified name
+			if path.chars.has(':') then
+				var ids = path.split("::")
+				var g = identify_group(ids.first)
+				if g != null then
+					scan_group(g)
+					var ms = g.mmodules_by_name(ids.last)
+
+					# Return exact match
+					for m in ms do
+						if m.full_name == path then
+							return m
+						end
+					end
+
+					# Where there is only one or two names `foo::bar`
+					# then accept module that matches `foo::*::bar`
+					if ids.length <= 2 then
+						if ms.length == 1 then return ms.first
+						if ms.length > 1 then
+							var l = new Array[String]
+							for m in ms do
+								var fp = m.filepath
+								if fp != null then fp = " ({fp})" else fp = ""
+								l.add "`{m.full_name}`{fp}"
+							end
+							last_loader_error = "Error: conflicting module for `{path}`: {l.join(", ")} "
+							return null
+						end
+					end
+
+					var bests = new BestDistance[String](path.length / 2)
+					# We found nothing. But propose something in the package?
+					for sg in g.mpackage.mgroups do
+						for m in sg.mmodules do
+							var d = path.levenshtein_distance(m.full_name)
+							bests.update(d, m.full_name)
+						end
+					end
+					var last_loader_error = "Error: cannot find module `{path}`."
+					if bests.best_items.not_empty then
+						last_loader_error += " Did you mean " + bests.best_items.join(", ", " or ") + "?"
+					end
+					self.last_loader_error = last_loader_error
+					return null
+				end
 			end
-			path = candidate
+
+			return null
 		end
 
 		# Does the file exists?
@@ -352,35 +449,45 @@ redef class ModelBuilder
 		end
 
 		# Fast track, the path is already known
-		var pn = path.basename(".nit")
+		if identified_modules_by_path.has_key(path) then return identified_modules_by_path[path]
 		var rp = module_absolute_path(path)
-		if identified_files_by_path.has_key(rp) then return identified_files_by_path[rp]
+		if identified_modules_by_path.has_key(rp) then return identified_modules_by_path[rp]
+
+		var pn = path.basename(".nit")
 
 		# Search for a group
 		var mgrouppath = path.join_path("..").simplify_path
-		var mgroup = get_mgroup(mgrouppath)
+		var mgroup = identify_group(mgrouppath)
 
+		if mgroup != null then
+			var mpackage = mgroup.mpackage
+			if not mpackage.accept(path) then
+				mgroup = null
+				toolcontext.info("module `{path}` excluded from package `{mpackage}`", 2)
+			end
+		end
 		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 singleton project `{pn}` at {path}", 2)
-
-			# Attach homonymous `ini` file to the project
+			# singleton package
+			var loc = new Location.opaque_file(path)
+			var mpackage = new MPackage(pn, model, loc)
+			mgroup = new MGroup(pn, loc, mpackage, null) # same name for the root group
+			mpackage.root = mgroup
+			toolcontext.info("found singleton package `{pn}` at {path}", 2)
+
+			# Attach homonymous `ini` file to the package
 			var inipath = path.dirname / "{pn}.ini"
 			if inipath.file_exists then
-				var ini = new ConfigTree(inipath)
-				mproject.ini = ini
+				var ini = new IniFile.from_file(inipath)
+				mpackage.ini = ini
 			end
 		end
 
-		var res = new ModulePath(pn, path, mgroup)
-		mgroup.module_paths.add(res)
+		var loc = new Location.opaque_file(path)
+		var res = new MModule(model, mgroup, pn, loc)
 
-		identified_files_by_path[rp] = res
-		identified_files.add(res)
+		identified_modules_by_path[rp] = res
+		identified_modules_by_path[path] = res
+		identified_modules.add(res)
 		return res
 	end
 
@@ -390,13 +497,25 @@ redef class ModelBuilder
 	# Return the mgroup associated to a directory path.
 	# If the directory is not a group null is returned.
 	#
+	# Silently return `null` if `dirpath` does not exists, is not a directory,
+	# cannot be identified or cannot be attached to a mpackage.
+	# If `null` is returned, `last_loader_error` can be set to a specific error message.
+	#
 	# Note: `paths` is also used to look for mgroups
-	fun get_mgroup(dirpath: String): nullable MGroup
+	fun identify_group(dirpath: String): nullable MGroup
 	do
-		if not dirpath.file_exists then do
+		# Reset error
+		last_loader_error = null
+
+		var stat = dirpath.file_stat
+
+		if stat == null or not stat.is_dir then do
+			# search dirless directories in known -I paths
+			if dirpath.chars.has('/') then return null
 			for p in paths do
 				var try = p / dirpath
-				if try.file_exists then
+				stat = try.file_stat
+				if stat != null then
 					dirpath = try
 					break label
 				end
@@ -404,27 +523,27 @@ redef class ModelBuilder
 			return null
 		end label
 
+		# Filter out non-directories
+		if not stat.is_dir then
+			last_loader_error = "Error: `{dirpath}` is not a directory."
+			return null
+		end
+
+		# Fast track, the path is already known
 		var rdp = module_absolute_path(dirpath)
 		if mgroups.has_key(rdp) then
 			return mgroups[rdp]
 		end
 
-		# Filter out non-directories
-		var stat = dirpath.file_stat
-		if stat == null or not stat.is_dir then
-			mgroups[rdp] = null
-			return null
-		end
+		# By default, the name of the package or group is the base_name of the directory
+		var pn = rdp.basename
 
-		# By default, the name of the project or group is the base_name of the directory
-		var pn = rdp.basename(".nit")
-
-		# Check `project.ini` that indicate a project
+		# Check `package.ini` that indicate a package
 		var ini = null
 		var parent = null
-		var inipath = dirpath / "project.ini"
+		var inipath = dirpath / "package.ini"
 		if inipath.file_exists then
-			ini = new ConfigTree(inipath)
+			ini = new IniFile.from_file(inipath)
 		end
 
 		if ini == null then
@@ -433,47 +552,57 @@ redef class ModelBuilder
 			# The root of the directory hierarchy in the file system.
 			if rdp == "/" then
 				mgroups[rdp] = null
+				last_loader_error = "Error: `{dirpath}` is not a Nit package."
 				return null
 			end
 
-			# Special stopper `projects.ini`
-			if (dirpath/"projects.ini").file_exists then
-				# dirpath cannot be a project since it is a project directory
+			# Special stopper `packages.ini`
+			if (dirpath/"packages.ini").file_exists then
+				# dirpath cannot be a package since it is a package directory
 				mgroups[rdp] = null
+				last_loader_error = "Error: `{dirpath}` is not a Nit package."
 				return null
 			end
 
 			# check the parent directory (if it does not contain the stopper file)
 			var parentpath = dirpath.join_path("..").simplify_path
-			var stopper = parentpath / "projects.ini"
+			var stopper = parentpath / "packages.ini"
 			if not stopper.file_exists then
 				# Recursively get the parent group
-				parent = get_mgroup(parentpath)
+				parent = identify_group(parentpath)
+				if parent != null then do
+					var mpackage = parent.mpackage
+					if not mpackage.accept(dirpath) then
+						toolcontext.info("directory `{dirpath}` excluded from package `{mpackage}`", 2)
+						parent = null
+					end
+				end
 				if parent == null then
 					# Parent is not a group, thus we are not a group either
 					mgroups[rdp] = null
+					last_loader_error = "Error: `{dirpath}` is not a Nit package."
 					return null
 				end
 			end
 		end
 
+		var loc = new Location.opaque_file(dirpath)
 		var mgroup
 		if parent == null then
-			# no parent, thus new project
-			var namekey = "project.name"
-			if ini != null and ini.has_key(namekey) then pn = ini[namekey]
-			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)
-			mproject.ini = ini
+			# no parent, thus new package
+			if ini != null then pn = ini["package.name"] or else pn
+			var mpackage = new MPackage(pn, model, loc)
+			mgroup = new MGroup(pn, loc, mpackage, null) # same name for the root group
+			mpackage.root = mgroup
+			toolcontext.info("found package `{mpackage}` at {dirpath}", 2)
+			mpackage.ini = ini
 		else
-			mgroup = new MGroup(pn, parent.mproject, parent)
+			mgroup = new MGroup(pn, loc, parent.mpackage, parent)
 			toolcontext.info("found sub group `{mgroup.full_name}` at {dirpath}", 2)
 		end
 
 		# search documentation
-		# in src first so the documentation of the project code can be distinct for the documentation of the project usage
+		# in src first so the documentation of the package code can be distinct for the documentation of the package usage
 		var readme = dirpath.join_path("README.md")
 		if not readme.file_exists then readme = dirpath.join_path("README")
 		if readme.file_exists then
@@ -482,7 +611,6 @@ redef class ModelBuilder
 			mdoc.original_mentity = mgroup
 		end
 
-		mgroup.filepath = dirpath
 		mgroups[rdp] = mgroup
 		return mgroup
 	end
@@ -508,12 +636,12 @@ redef class ModelBuilder
 		return mdoc
 	end
 
-	# Force the identification of all ModulePath of the group and sub-groups in the file system.
+	# Force the identification of all MModule of the group and sub-groups in the file system.
 	#
 	# When a group is scanned, its sub-groups hierarchy is filled (see `MGroup::in_nesting`)
-	# and the potential modules (and nested modules) are identified (see `MGroup::module_paths`).
+	# and the potential modules (and nested modules) are identified (see `MGroup::modules`).
 	#
-	# Basically, this recursively call `get_mgroup` and `identify_file` on each directory entry.
+	# Basically, this recursively call `identify_group` and `identify_module` on each directory entry.
 	#
 	# No-op if the group was already scanned (see `MGroup::scanned`).
 	fun scan_group(mgroup: MGroup) do
@@ -522,27 +650,35 @@ redef class ModelBuilder
 		var p = mgroup.filepath
 		# a virtual group has nothing to scan
 		if p == null then return
-		for f in p.files do
+		var files = p.files
+		alpha_comparator.sort(files)
+		for f in files do
+			if f.first == '.' then continue
 			var fp = p/f
-			var g = get_mgroup(fp)
-			# Recursively scan for groups of the same project
-			if g != null and g.mproject == mgroup.mproject then
+			var g = identify_group(fp)
+			# Recursively scan for groups of the same package
+			if g == null then
+				identify_module(fp)
+			else if g.mpackage == mgroup.mpackage then
 				scan_group(g)
 			end
-			identify_file(fp)
 		end
 	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
+		return path.realpath
 	end
 
 	# Try to load a module AST using a path.
 	# Display an error if there is a problem (IO / lexer / parser) and return null
+	#
+	# The AST is loaded as is total independence of the model and its entities.
+	#
+	# AST are not cached or reused thus a new AST is returned on success.
 	fun load_module_ast(filename: String): nullable AModule
 	do
-		if filename.file_extension != "nit" then
+		if not filename.has_suffix(".nit") then
 			self.toolcontext.error(null, "Error: file `{filename}` is not a valid nit module.")
 			return null
 		end
@@ -580,7 +716,12 @@ redef class ModelBuilder
 		var keep = new Array[String]
 		var res = new Array[String]
 		for a in args do
-			var l = identify_file(a)
+			var stat = a.to_path.stat
+			if stat != null and stat.is_dir then
+				res.add a
+				continue
+			end
+			var l = identify_module(a)
 			if l == null then
 				keep.add a
 			else
@@ -596,14 +737,16 @@ redef class ModelBuilder
 	# 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.
 	#
-	# The MModule is created however, the importation is not performed,
-	# therefore you should call `build_module_importation`.
+	# The MModule is located, created, parsed and the importation is performed.
 	fun load_module(filename: String): nullable AModule
 	do
 		# Look for the module
-		var file = identify_file(filename)
-		if file == null then
-			if filename.file_exists then
+		var mmodule = identify_module(filename)
+		if mmodule == null then
+			var le = last_loader_error
+			if le != null then
+				toolcontext.error(null, le)
+			else if filename.file_exists then
 				toolcontext.error(null, "Error: `{filename}` is not a Nit source file.")
 			else
 				toolcontext.error(null, "Error: cannot find module `{filename}`.")
@@ -611,30 +754,13 @@ redef class ModelBuilder
 			return null
 		end
 
-		# 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
-
-		return nmodule
+		# Load it
+		return mmodule.load(self)
 	end
 
 	# Injection of a new module without source.
 	# Used by the interpreter.
-	fun load_rt_module(parent: nullable MModule, nmodule: AModule, mod_name: String): nullable AModule
+	fun load_rt_module(parent: nullable MModule, nmodule: AModule, mod_name: String): nullable MModule
 	do
 		# Create the module
 
@@ -643,6 +769,7 @@ redef class ModelBuilder
 		var mmodule = new MModule(model, mgroup, mod_name, nmodule.location)
 		nmodule.mmodule = mmodule
 		nmodules.add(nmodule)
+		parsed_modules.add mmodule
 		self.mmodule2nmodule[mmodule] = nmodule
 
 		if parent!= null then
@@ -650,30 +777,32 @@ redef class ModelBuilder
 			imported_modules.add(parent)
 			mmodule.set_visibility_for(parent, intrude_visibility)
 			mmodule.set_imported_mmodules(imported_modules)
-		else
-			build_module_importation(nmodule)
 		end
+		build_module_importation(nmodule)
 
-		return nmodule
+		return mmodule
 	end
 
 	# Visit the AST and create the `MModule` object
-	private fun build_a_mmodule(mgroup: nullable MGroup, mod_name: String, nmodule: AModule): nullable MModule
+	private fun build_a_mmodule(mgroup: nullable MGroup, nmodule: AModule)
 	do
+		var mmodule = nmodule.mmodule
+		assert mmodule != null
+
 		# Check the module name
 		var decl = nmodule.n_moduledecl
 		if decl != null then
 			var decl_name = decl.n_name.n_id.text
-			if decl_name != mod_name then
-				error(decl.n_name, "Error: module name mismatch; declared {decl_name} file named {mod_name}.")
+			if decl_name != mmodule.name then
+				warning(decl.n_name, "module-name-mismatch", "Error: module name mismatch; declared {decl_name} file named {mmodule.name}.")
 			end
 		end
 
-		# Check for conflicting module names in the project
+		# Check for conflicting module names in the package
 		if mgroup != null then
-			var others = model.get_mmodules_by_name(mod_name)
+			var others = model.get_mmodules_by_name(mmodule.name)
 			if others != null then for other in others do
-				if other.mgroup!= null and other.mgroup.mproject == mgroup.mproject then
+				if other != mmodule and mmodule2nmodule.has_key(mmodule) and other.mgroup!= null and other.mgroup.mpackage == mgroup.mpackage then
 					var node: ANode
 					if decl == null then node = nmodule else node = decl.n_name
 					error(node, "Error: a module named `{other.full_name}` already exists at {other.location}.")
@@ -682,9 +811,6 @@ redef class ModelBuilder
 			end
 		end
 
-		# Create the module
-		var mmodule = new MModule(model, mgroup, mod_name, nmodule.location)
-		nmodule.mmodule = mmodule
 		nmodules.add(nmodule)
 		self.mmodule2nmodule[mmodule] = nmodule
 
@@ -701,20 +827,16 @@ redef class ModelBuilder
 				var mdoc = ndoc.to_mdoc
 				mmodule.mdoc = mdoc
 				mdoc.original_mentity = mmodule
-			else
-				advice(decl, "missing-doc", "Documentation warning: Undocumented module `{mmodule}`")
 			end
-			# Is the module a test suite?
-			mmodule.is_test_suite = not decl.get_annotations("test_suite").is_empty
+			# Is the module generated?
+			mmodule.is_generated = not decl.get_annotations("generated").is_empty
 		end
-
-		return mmodule
 	end
 
 	# Resolve the module identification for a given `AModuleName`.
 	#
 	# This method handles qualified names as used in `AModuleName`.
-	fun seach_module_by_amodule_name(n_name: AModuleName, mgroup: nullable MGroup): nullable ModulePath
+	fun search_module_by_amodule_name(n_name: AModuleName, mgroup: nullable MGroup): nullable MModule
 	do
 		var mod_name = n_name.n_id.text
 
@@ -729,17 +851,17 @@ redef class ModelBuilder
 
 		# If qualified and in a group
 		if mgroup != null then
-			# First search in the project
-			var r = mgroup.mproject.root
+			# First search in the package
+			var r = mgroup.mpackage.root
 			assert r != null
 			scan_group(r)
 			# Get all modules with the final name
-			var res = r.mmodule_paths_by_name(mod_name)
+			var res = r.mmodules_by_name(mod_name)
 			# Filter out the name that does not match the qualifiers
 			res = [for x in res do if match_amodulename(n_name, x) then x]
 			if res.not_empty then
 				if res.length > 1 then
-					error(n_name, "Error: conflicting module files for `{mod_name}`: `{res.join(",")}`")
+					error(n_name, "Error: conflicting module files for `{mod_name}`: `{[for x in res do x.filepath or else x.full_name].join("`, `")}`")
 				end
 				return res.first
 			end
@@ -748,22 +870,29 @@ redef class ModelBuilder
 		# If no module yet, then assume that the first element of the path
 		# Is to be searched in the path.
 		var root_name = n_name.n_path.first.text
+
+		# Search for an alias in required external packages
+		if mgroup != null then
+			var alias = mgroup.mpackage.import_alias(root_name)
+			if alias != null then root_name = alias
+		end
+
 		var roots = search_group_in_paths(root_name, paths)
 		if roots.is_empty then
 			error(n_name, "Error: cannot find `{root_name}`. Tried: {paths.join(", ")}.")
 			return null
 		end
 
-		var res = new ArraySet[ModulePath]
+		var res = new ArraySet[MModule]
 		for r in roots do
 			# Then, for each root, collect modules that matches the qualifiers
 			scan_group(r)
-			var root_res = r.mmodule_paths_by_name(mod_name)
+			var root_res = r.mmodules_by_name(mod_name)
 			for x in root_res do if match_amodulename(n_name, x) then res.add x
 		end
 		if res.not_empty then
 			if res.length > 1 then
-				error(n_name, "Error: conflicting module files for `{mod_name}`: `{res.join(",")}`")
+				error(n_name, "Error: conflicting module files for `{mod_name}`: `{[for x in res do x.filepath or else x.full_name].join("`, `")}`")
 			end
 			return res.first
 		end
@@ -777,8 +906,8 @@ redef class ModelBuilder
 	# Basically it check that `bar::foo` matches `bar/foo.nit` and `bar/baz/foo.nit`
 	# but not `baz/foo.nit` nor `foo/bar.nit`
 	#
-	# Is used by `seach_module_by_amodule_name` to validate qualified names.
-	private fun match_amodulename(n_name: AModuleName, m: ModulePath): Bool
+	# Is used by `search_module_by_amodule_name` to validate qualified names.
+	private fun match_amodulename(n_name: AModuleName, m: MModule): Bool
 	do
 		var g: nullable MGroup = m.mgroup
 		for grp in n_name.n_path.reverse_iterator do
@@ -791,7 +920,10 @@ redef class ModelBuilder
 
 	# Analyze the module importation and fill the module_importation_hierarchy
 	#
-	# Unless you used `load_module`, the importation is already done and this method does a no-op.
+	# If the importation was already done (`nmodule.is_importation_done`), this method does a no-op.
+	#
+	# REQUIRE `nmodule.mmodule != null`
+	# ENSURE `nmodule.is_importation_done`
 	fun build_module_importation(nmodule: AModule)
 	do
 		if nmodule.is_importation_done then return
@@ -810,13 +942,15 @@ redef class ModelBuilder
 			end
 
 			# Load the imported module
-			var suppath = seach_module_by_amodule_name(aimport.n_name, mmodule.mgroup)
-			if suppath == null then
+			var sup = search_module_by_amodule_name(aimport.n_name, mmodule.mgroup)
+			if sup == null then
+				mmodule.is_broken = true
 				nmodule.mmodule = null # invalidate the module
 				continue # Skip error
 			end
-			var sup = load_module_path(suppath)
-			if sup == null then
+			var ast = sup.load(self)
+			if ast == null then
+				mmodule.is_broken = true
 				nmodule.mmodule = null # invalidate the module
 				continue # Skip error
 			end
@@ -825,16 +959,20 @@ redef class ModelBuilder
 			imported_modules.add(sup)
 			var mvisibility = aimport.n_visibility.mvisibility
 			if mvisibility == protected_visibility then
+				mmodule.is_broken = true
 				error(aimport.n_visibility, "Error: only properties can be protected.")
+				mmodule.is_broken = true
 				nmodule.mmodule = null # invalidate the module
 				return
 			end
 			if sup == mmodule then
 				error(aimport.n_name, "Error: dependency loop in module {mmodule}.")
+				mmodule.is_broken = true
 				nmodule.mmodule = null # invalidate the module
 			end
 			if sup.in_importation < mmodule then
 				error(aimport.n_name, "Error: dependency loop between modules {mmodule} and {sup}.")
+				mmodule.is_broken = true
 				nmodule.mmodule = null # invalidate the module
 				return
 			end
@@ -844,6 +982,7 @@ redef class ModelBuilder
 			var mod_name = "core"
 			var sup = self.get_mmodule_by_name(nmodule, null, mod_name)
 			if sup == null then
+				mmodule.is_broken = true
 				nmodule.mmodule = null # invalidate the module
 			else # Skip error
 				imported_modules.add(sup)
@@ -857,7 +996,7 @@ redef class ModelBuilder
 			var atconditionals = aimport.get_annotations("conditional")
 			if atconditionals.is_empty then continue
 
-			var suppath = seach_module_by_amodule_name(aimport.n_name, mmodule.mgroup)
+			var suppath = search_module_by_amodule_name(aimport.n_name, mmodule.mgroup)
 			if suppath == null then continue # skip error
 
 			for atconditional in atconditionals do
@@ -868,7 +1007,7 @@ redef class ModelBuilder
 				end
 
 				# The rule
-				var rule = new Array[Object]
+				var rule = new Array[MModule]
 
 				# First element is the goal, thus
 				rule.add suppath
@@ -926,14 +1065,11 @@ redef class ModelBuilder
 	# It means that the first module is the module to automatically import.
 	# The remaining modules are the conditions of the rule.
 	#
-	# Each module is either represented by a MModule (if the module is already loaded)
-	# or by a ModulePath (if the module is not yet loaded).
-	#
 	# Rules are declared by `build_module_importation` and are applied by `apply_conditional_importations`
 	# (and `build_module_importation` that calls it).
 	#
 	# TODO (when the loader will be rewritten): use a better representation and move up rules in the model.
-	private var conditional_importations = new Array[SequenceRead[Object]]
+	var conditional_importations = new Array[SequenceRead[MModule]]
 
 	# Extends the current importations according to imported rules about conditional importation
 	fun apply_conditional_importations(mmodule: MModule)
@@ -947,28 +1083,16 @@ redef class ModelBuilder
 			for ci in conditional_importations do
 				# Check conditions
 				for i in [1..ci.length[ do
-					var rule_element = ci[i]
-					# An element of a rule is either a MModule or a ModulePath
-					# We need the mmodule to resonate on the importation
-					var m
-					if rule_element isa MModule then
-						m = rule_element
-					else if rule_element isa ModulePath then
-						m = rule_element.mmodule
-						# Is loaded?
-						if m == null then continue label
-					else
-						abort
-					end
+					var m = ci[i]
 					# Is imported?
-					if not mmodule.in_importation.greaters.has(m) then continue label
+					if mmodule == m or not mmodule.in_importation.greaters.has(m) then continue label
 				end
 				# Still here? It means that all conditions modules are loaded and imported
 
 				# Identify the module to automatically import
-				var suppath = ci.first.as(ModulePath)
-				var sup = load_module_path(suppath)
-				if sup == null then continue
+				var sup = ci.first
+				var ast = sup.load(self)
+				if ast == null then continue
 
 				# Do nothing if already imported
 				if mmodule.in_importation.greaters.has(sup) then continue label
@@ -1004,40 +1128,109 @@ redef class ModelBuilder
 	end
 end
 
-# File-system location of a module (file) that is identified but not always loaded.
-class ModulePath
-	# The name of the module
-	# (it's the basename of the filepath)
-	var name: String
+redef class MModule
+	# Force the parsing of the module using `modelbuilder`.
+	#
+	# If the module was already parsed, the existing ASI is returned.
+	# Else the source file is loaded, and parsed and some
+	#
+	# The importation is not done by this
+	#
+	# REQUIRE: `filepath != null`
+	# ENSURE: `modelbuilder.parsed_modules.has(self)`
+	fun parse(modelbuilder: ModelBuilder): nullable AModule
+	do
+		# Already known and loaded? then return it
+		var nmodule = modelbuilder.mmodule2nmodule.get_or_null(self)
+		if nmodule != null then return nmodule
 
-	# The human path of the module
-	var filepath: String
+		var filepath = self.filepath
+		assert filepath != null
+		# Load it manually
+		nmodule = modelbuilder.load_module_ast(filepath)
+		if nmodule == null then return null # forward error
 
-	# The group (and the project) of the possible module
-	var mgroup: MGroup
+		# build the mmodule
+		nmodule.mmodule = self
+		self.location = nmodule.location
+		modelbuilder.build_a_mmodule(mgroup, nmodule)
 
-	# The loaded module (if any)
-	var mmodule: nullable MModule = null
+		modelbuilder.parsed_modules.add self
+		return nmodule
+	end
+
+	# Parse and process importation of a given MModule.
+	#
+	# Basically chains `parse` and `build_module_importation`.
+	fun load(modelbuilder: ModelBuilder): nullable AModule
+	do
+		var nmodule = parse(modelbuilder)
+		if nmodule == null then return null
 
-	redef fun to_s do return filepath
+		modelbuilder.build_module_importation(nmodule)
+		return nmodule
+	end
 end
 
-redef class MProject
+redef class MPackage
 	# The associated `.ini` file, if any
 	#
 	# The `ini` file is given as is and might contain invalid or missing information.
 	#
-	# Some projects, like stand-alone projects or virtual projects have no `ini` file associated.
-	var ini: nullable ConfigTree = null
+	# Some packages, like stand-alone packages or virtual packages have no `ini` file associated.
+	var ini: nullable IniFile = null
+
+	# Array of relative source paths excluded according to the `source.exclude` key of the `ini`
+	var excludes: nullable Array[String] is lazy do
+		var ini = self.ini
+		if ini == null then return null
+		var exclude = ini["source.exclude"]
+		if exclude == null then return null
+		var excludes = exclude.split(":")
+		return excludes
+	end
+
+	# Does the source inclusion/inclusion rules of the package `ini` accept such path?
+	fun accept(filepath: String): Bool
+	do
+		var excludes = self.excludes
+		if excludes != null then
+			var relpath = root.filepath.relpath(filepath)
+			if excludes.has(relpath) then return false
+		end
+		return true
+	end
+
+	# Get the name to search for, for a `root_name` declared as `import` in `ini`
+	fun import_alias(root_name: String): nullable String
+	do
+		var map = import_aliases_parsed
+		if map == null then return null
+
+		var val = map.get_or_null(root_name)
+		if val == null then return null
+
+		return val.dir_name
+	end
+
+	private var import_aliases_parsed: nullable Map[String, ExternalPackage] is lazy do
+		var ini = ini
+		if ini == null then return null
+
+		var import_line = ini["package.import"]
+		if import_line == null then return null
+
+		var map = import_line.parse_import
+		if map.is_empty then return null
+
+		return map
+	end
 end
 
 redef class MGroup
-	# Modules paths associated with the group
-	var module_paths = new Array[ModulePath]
-
 	# Is the group interesting for a final user?
 	#
-	# Groups are mandatory in the model but for simple projects they are not
+	# Groups are mandatory in the model but for simple packages they are not
 	# always interesting.
 	#
 	# A interesting group has, at least, one of the following true:
@@ -1047,8 +1240,7 @@ redef class MGroup
 	# * it has a documentation
 	fun is_interesting: Bool
 	do
-		return module_paths.length > 1 or
-			mmodules.length > 1 or
+		return mmodules.length > 1 or
 			not in_nesting.direct_smallers.is_empty or
 			mdoc != null or
 			(mmodules.length == 1 and default_mmodule == null)
@@ -1063,11 +1255,11 @@ redef class MGroup
 	#
 	# If `self` is not scanned (see `ModelBuilder::scan_group`) the
 	# results might be partial.
-	fun mmodule_paths_by_name(name: String): Array[ModulePath]
+	fun mmodules_by_name(name: String): Array[MModule]
 	do
-		var res = new Array[ModulePath]
+		var res = new Array[MModule]
 		for g in in_nesting.smallers do
-			for mp in g.module_paths do
+			for mp in g.mmodules do
 				if mp.name == name then
 					res.add mp
 				end
@@ -1089,7 +1281,8 @@ end
 
 redef class AModule
 	# The associated MModule once build by a `ModelBuilder`
-	var mmodule: nullable MModule
+	var mmodule: nullable MModule = null
+
 	# Flag that indicate if the importation is already completed
 	var is_importation_done: Bool = false
 end