# 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
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 packages.
- # * a short name of a module or a group that are looked in the `paths` (-I)
- #
- # Then, for each entry, if it is:
+ # Identify a bunch of modules and groups.
#
- # * a module, then is it parser 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]
+ # 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
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
- 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)
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
+ 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
# 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
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
# 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 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)
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
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
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]
# 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 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
+ #
+ # 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
# special case for not a nit file
if not path.has_suffix(".nit") then
# 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
end
# Fast track, the path is already known
- if identified_files_by_path.has_key(path) then return identified_files_by_path[path]
+ 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
# singleton package
end
end
- var res = new ModulePath(pn, path, mgroup)
- mgroup.module_paths.add(res)
+ var src = new SourceFile.from_string(path, "")
+ var loc = new Location(src, 0, 0, 0, 0)
+ var res = new MModule(model, mgroup, pn, loc)
+ res.filepath = path
- identified_files_by_path[rp] = res
- identified_files_by_path[path] = res
- identified_files.add(res)
+ identified_modules_by_path[rp] = res
+ identified_modules_by_path[path] = res
+ identified_modules.add(res)
return res
end
# If the directory is not a group null is returned.
#
# Note: `paths` is also used to look for mgroups
- fun get_mgroup(dirpath: String): nullable MGroup
+ fun identify_group(dirpath: String): nullable MGroup
do
var stat = dirpath.file_stat
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
# Parent is not a group, thus we are not a group either
mgroups[rdp] = null
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 = get_mgroup(fp)
+ var g = identify_group(fp)
# Recursively scan for groups of the same package
if g == null then
- identify_file(fp)
+ identify_module(fp)
else if g.mpackage == mgroup.mpackage then
scan_group(g)
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 not filename.has_suffix(".nit") then
var keep = new Array[String]
var res = new Array[String]
for a in args do
- var l = identify_file(a)
+ var l = identify_module(a)
if l == null then
keep.add a
else
# 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
+ var mmodule = identify_module(filename)
+ if mmodule == null then
if filename.file_exists then
toolcontext.error(null, "Error: `{filename}` is not a Nit source file.")
else
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.
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
+ error(decl.n_name, "Error: module name mismatch; declared {decl_name} file named {mmodule.name}.")
end
end
# 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.mpackage == mgroup.mpackage 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}.")
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
# Is the module a test suite?
mmodule.is_test_suite = not decl.get_annotations("test_suite").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 seach_module_by_amodule_name(n_name: AModuleName, mgroup: nullable MGroup): nullable MModule
do
var mod_name = n_name.n_id.text
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
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
# 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
+ 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
# 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
# Load the imported module
- var suppath = seach_module_by_amodule_name(aimport.n_name, mmodule.mgroup)
- if suppath == null then
+ var sup = seach_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
# 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 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
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
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
+ # The path of the module source
+ var filepath: nullable String = null
- # The human path of the module
- var filepath: String
+ # 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 group (and the package) of the possible module
- var mgroup: MGroup
+ 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 loaded module (if any)
- var mmodule: nullable MModule = null
+ # build the mmodule
+ nmodule.mmodule = self
+ modelbuilder.build_a_mmodule(mgroup, nmodule)
+
+ 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 MPackage
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 packages they are not
# * 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)
#
# 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
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
*** METRICS ***
+--- AST Metrics ---
+## All nodes of the AST
+ population: 51
+ minimum value: 1
+ maximum value: 40
+ total value: 289
+ average value: 5.66
+ distribution:
+ <=1: sub-population=16 (31.37%); cumulated value=16 (5.53%)
+ <=2: sub-population=5 (9.80%); cumulated value=10 (3.46%)
+ <=4: sub-population=9 (17.64%); cumulated value=28 (9.68%)
+ <=8: sub-population=12 (23.52%); cumulated value=76 (26.29%)
+ <=16: sub-population=4 (7.84%); cumulated value=44 (15.22%)
+ <=32: sub-population=4 (7.84%); cumulated value=75 (25.95%)
+ <=64: sub-population=1 (1.96%); cumulated value=40 (13.84%)
+ list:
+ TId: 40 (13.84%)
+ APublicVisibility: 19 (6.57%)
+ AQid: 19 (6.57%)
+ AListExprs: 19 (6.57%)
+ ACallExpr: 18 (6.22%)
+ TClassid: 15 (5.19%)
+ TInteger: 10 (3.46%)
+ AIntegerExpr: 10 (3.46%)
+ AType: 9 (3.11%)
+ TKwend: 8 (2.76%)
+ ...
+ ACallAssignExpr: 1 (0.34%)
+ AAnnotations: 1 (0.34%)
+ TKwreturn: 1 (0.34%)
+ AReturnExpr: 1 (0.34%)
+ AInterfaceClasskind: 1 (0.34%)
+ TKwinterface: 1 (0.34%)
+ ANoImport: 1 (0.34%)
+ AMainMethPropdef: 1 (0.34%)
+ AMainClassdef: 1 (0.34%)
+ TKwimport: 1 (0.34%)
+## All identifiers of the AST
+ population: 20
+ minimum value: 1
+ maximum value: 11
+ total value: 55
+ average value: 2.75
+ distribution:
+ <=1: sub-population=3 (15.00%); cumulated value=3 (5.45%)
+ <=2: sub-population=12 (60.00%); cumulated value=24 (43.63%)
+ <=4: sub-population=3 (15.00%); cumulated value=10 (18.18%)
+ <=8: sub-population=1 (5.00%); cumulated value=7 (12.72%)
+ <=16: sub-population=1 (5.00%); cumulated value=11 (20.00%)
+ list:
+ output: 11 (20.00%)
+ Int: 7 (12.72%)
+ run: 4 (7.27%)
+ c: 3 (5.45%)
+ val: 3 (5.45%)
+ i: 2 (3.63%)
+ bar: 2 (3.63%)
+ foo: 2 (3.63%)
+ val2: 2 (3.63%)
+ val1: 2 (3.63%)
+ C: 2 (3.63%)
+ v: 2 (3.63%)
+ baz: 2 (3.63%)
+ a: 2 (3.63%)
+ A: 2 (3.63%)
+ B: 2 (3.63%)
+ b: 2 (3.63%)
+ intern: 1 (1.81%)
+ Object: 1 (1.81%)
+ Bool: 1 (1.81%)
+--- Detection of variance constraints on formal parameter types ---
+-- Generic classes --
+ list:
+ non generic: 7 (100.00%)
+ total classes: 7
+ total formal parameters: 0
+-- Including `private` properties --
+ covariants: 0 (na%)
+ contravariants: 0 (na%)
+ bivariants: 0 (na%)
+ invariants: 0 (na%)
+ total: 0
+-- Excluding `private` properties --
+ covariants: 0 (na%)
+ contravariants: 0 (na%)
+ bivariants: 0 (na%)
+ invariants: 0 (na%)
+ total: 0
# MModules metrics
min: base_simple3 (1)
std: 0.0
sum: 1
---- Metrics of refinement usage ---
-Number of modules: 1
-
-Number of classes: 7
- Number of interface kind: 1 (14.28%)
- Number of enum kind: 2 (28.57%)
- Number of class kind: 4 (57.14%)
-
-Number of class definitions: 7
-Number of refined classes: 0 (0.00%)
-Average number of class refinments by classes: 0.00
-Average number of class refinments by refined classes: na
-
-Number of properties: 18
- Number of MAttribute: 3 (16.66%)
- Number of MMethod: 15 (83.33%)
-
-Number of property definitions: 20
-Number of redefined properties: 1 (5.55%)
-Average number of property redefinitions by property: 0.11
-Average number of property redefinitions by redefined property: 2.00
---- Explicit vs. Implicit Self ---
-Total number of self: 5
-Total number of implicit self: 4 (80.00%)
---- Construction of tables ---
-Number of runtime classes: 6 (excluding interfaces and abstract classes)
-Average number of composing class definition by runtime class: 2.00
-Total size of tables (classes and instances): 23 (not including stuff like info for subtyping or call-next-method)
-Average size of table by runtime class: 3.83
-Values never redefined: 17 (73.91%)
--- Poset metrics ---
## Module importation hierarchy
Number of nodes: 1
distribution:
<=0: sub-population=6 (85.71%); cumulated value=0 (0.00%)
<=8: sub-population=1 (14.28%); cumulated value=6 (100.00%)
---- AST Metrics ---
-## All nodes of the AST
- population: 51
- minimum value: 1
- maximum value: 40
- total value: 289
- average value: 5.66
- distribution:
- <=1: sub-population=16 (31.37%); cumulated value=16 (5.53%)
- <=2: sub-population=5 (9.80%); cumulated value=10 (3.46%)
- <=4: sub-population=9 (17.64%); cumulated value=28 (9.68%)
- <=8: sub-population=12 (23.52%); cumulated value=76 (26.29%)
- <=16: sub-population=4 (7.84%); cumulated value=44 (15.22%)
- <=32: sub-population=4 (7.84%); cumulated value=75 (25.95%)
- <=64: sub-population=1 (1.96%); cumulated value=40 (13.84%)
- list:
- TId: 40 (13.84%)
- APublicVisibility: 19 (6.57%)
- AQid: 19 (6.57%)
- AListExprs: 19 (6.57%)
- ACallExpr: 18 (6.22%)
- TClassid: 15 (5.19%)
- TInteger: 10 (3.46%)
- AIntegerExpr: 10 (3.46%)
- AType: 9 (3.11%)
- TKwend: 8 (2.76%)
- ...
- ACallAssignExpr: 1 (0.34%)
- AAnnotations: 1 (0.34%)
- TKwreturn: 1 (0.34%)
- AReturnExpr: 1 (0.34%)
- AInterfaceClasskind: 1 (0.34%)
- TKwinterface: 1 (0.34%)
- ANoImport: 1 (0.34%)
- AMainMethPropdef: 1 (0.34%)
- AMainClassdef: 1 (0.34%)
- TKwimport: 1 (0.34%)
-## All identifiers of the AST
- population: 20
- minimum value: 1
- maximum value: 11
- total value: 55
- average value: 2.75
- distribution:
- <=1: sub-population=3 (15.00%); cumulated value=3 (5.45%)
- <=2: sub-population=12 (60.00%); cumulated value=24 (43.63%)
- <=4: sub-population=3 (15.00%); cumulated value=10 (18.18%)
- <=8: sub-population=1 (5.00%); cumulated value=7 (12.72%)
- <=16: sub-population=1 (5.00%); cumulated value=11 (20.00%)
- list:
- output: 11 (20.00%)
- Int: 7 (12.72%)
- run: 4 (7.27%)
- c: 3 (5.45%)
- val: 3 (5.45%)
- i: 2 (3.63%)
- bar: 2 (3.63%)
- foo: 2 (3.63%)
- val2: 2 (3.63%)
- val1: 2 (3.63%)
- C: 2 (3.63%)
- v: 2 (3.63%)
- baz: 2 (3.63%)
- a: 2 (3.63%)
- A: 2 (3.63%)
- B: 2 (3.63%)
- b: 2 (3.63%)
- intern: 1 (1.81%)
- Object: 1 (1.81%)
- Bool: 1 (1.81%)
---- Detection of variance constraints on formal parameter types ---
--- Generic classes --
- list:
- non generic: 7 (100.00%)
- total classes: 7
- total formal parameters: 0
--- Including `private` properties --
- covariants: 0 (na%)
- contravariants: 0 (na%)
- bivariants: 0 (na%)
- invariants: 0 (na%)
- total: 0
--- Excluding `private` properties --
- covariants: 0 (na%)
- contravariants: 0 (na%)
- bivariants: 0 (na%)
- invariants: 0 (na%)
- total: 0
+--- Metrics of refinement usage ---
+Number of modules: 1
+
+Number of classes: 7
+ Number of interface kind: 1 (14.28%)
+ Number of enum kind: 2 (28.57%)
+ Number of class kind: 4 (57.14%)
+
+Number of class definitions: 7
+Number of refined classes: 0 (0.00%)
+Average number of class refinments by classes: 0.00
+Average number of class refinments by refined classes: na
+
+Number of properties: 18
+ Number of MAttribute: 3 (16.66%)
+ Number of MMethod: 15 (83.33%)
+
+Number of property definitions: 20
+Number of redefined properties: 1 (5.55%)
+Average number of property redefinitions by property: 0.11
+Average number of property redefinitions by redefined property: 2.00
+--- Explicit vs. Implicit Self ---
+Total number of self: 5
+Total number of implicit self: 4 (80.00%)
+--- Construction of tables ---
+Number of runtime classes: 6 (excluding interfaces and abstract classes)
+Average number of composing class definition by runtime class: 2.00
+Total size of tables (classes and instances): 23 (not including stuff like info for subtyping or call-next-method)
+Average size of table by runtime class: 3.83
+Values never redefined: 17 (73.91%)
+generating package_hierarchy.dot
+generating module_hierarchy.dot
# MClasses metrics
min: Object (0)
std: 0.926
sum: 6
-generating package_hierarchy.dot
-generating module_hierarchy.dot
# Inheritance metrics
nitlanguage / nit.git / commitdiff