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.
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 = identify_group(af)
if mgroup != null then
var mmodule = identify_module(a)
if mmodule == null then
- if a.file_exists 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}`.")
# 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 package and groups if required.
#
# This method does what the user expects when giving an argument to a Nit tool.
# 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.
+ # 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 not path.has_suffix(".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)
end
# Found nothing? maybe it is a group...
- var candidate = null
if path.file_exists then
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?
var mgrouppath = path.join_path("..").simplify_path
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 package
var loc = new Location.opaque_file(path)
var loc = new Location.opaque_file(path)
var res = new MModule(model, mgroup, pn, loc)
- res.filepath = path
identified_modules_by_path[rp] = res
identified_modules_by_path[path] = res
# 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 identify_group(dirpath: String): nullable MGroup
do
+ # Reset error
+ last_loader_error = null
+
var stat = dirpath.file_stat
- if stat == null then do
+ 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
# Filter out non-directories
if not stat.is_dir then
+ last_loader_error = "Error: `{dirpath}` is not a directory."
return null
end
# 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
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
if not stopper.file_exists then
# Recursively get the parent group
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
mdoc.original_mentity = mgroup
end
- mgroup.filepath = dirpath
mgroups[rdp] = mgroup
return mgroup
end
var files = p.files
alpha_comparator.sort(files)
for f in files do
+ if f.first == '.' then continue
var fp = p/f
var g = identify_group(fp)
# Recursively scan for groups of the same package
var keep = new Array[String]
var res = new Array[String]
for a in args do
+ 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
# Look for the module
var mmodule = identify_module(filename)
if mmodule == null then
- if filename.file_exists 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}`.")
# 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
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
if decl != null then
var decl_name = decl.n_name.n_id.text
if decl_name != mmodule.name then
- error(decl.n_name, "Error: module name mismatch; declared {decl_name} file named {mmodule.name}.")
+ warning(decl.n_name, "module-name-mismatch", "Error: module name mismatch; declared {decl_name} file named {mmodule.name}.")
end
end
mmodule.mdoc = mdoc
mdoc.original_mentity = 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
end
# (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[MModule]]
+ 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 i in [1..ci.length[ do
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
#
# Some packages, like stand-alone packages or virtual packages have no `ini` file associated.
var ini: nullable ConfigTree = 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
end
redef class MGroup