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

diff --git a/src/loader.nit b/src/loader.nit
index a1a5dc1..0ae8ff0 100644
--- a/src/loader.nit
+++ b/src/loader.nit
@@ -15,6 +15,26 @@
 # 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
@@ -505,12 +525,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
@@ -538,6 +558,10 @@ redef class ModelBuilder
 
 	# 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 not filename.has_suffix(".nit") then
@@ -769,7 +793,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
@@ -853,7 +880,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
@@ -911,14 +938,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]]
+	private var conditional_importations = new Array[SequenceRead[MModule]]
 
 	# Extends the current importations according to imported rules about conditional importation
 	fun apply_conditional_importations(mmodule: MModule)
@@ -932,24 +956,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
-						abort
-					end
+					var m = ci[i]
 					# Is imported?
 					if 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