# 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
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
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
var af = a/f
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
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
var fp = p/f
var g = identify_group(fp)
# Recursively scan for groups of the same package
# 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
# 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
end
# The rule
- var rule = new Array[Object]
+ var rule = new Array[MModule]
# First element is the goal, thus
rule.add suppath
# 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)
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
var nmodule = parse(modelbuilder)
if nmodule == null then return null
+ modelbuilder.build_module_importation(nmodule)
return nmodule
end
end
nitlanguage / nit.git / blobdiff