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

diff --git a/src/modelbuilder.nit b/src/modelbuilder.nit
index c9e5603..1ae7e45 100644
--- a/src/modelbuilder.nit
+++ b/src/modelbuilder.nit
@@ -22,11 +22,7 @@
 # FIXME add missing error checks
 module modelbuilder
 
-import parser
 import model
-import poset
-import opts
-import toolcontext
 import phase
 
 private import more_collections
@@ -35,36 +31,70 @@ private import more_collections
 
 redef class ToolContext
 	# Option --path
-	var opt_path: OptionArray = new OptionArray("Set include path for loaders (may be used more than once)", "-I", "--path")
+	var opt_path = new OptionArray("Set include path for loaders (may be used more than once)", "-I", "--path")
 
 	# Option --only-metamodel
-	var opt_only_metamodel: OptionBool = new OptionBool("Stop after meta-model processing", "--only-metamodel")
+	var opt_only_metamodel = new OptionBool("Stop after meta-model processing", "--only-metamodel")
 
 	# Option --only-parse
-	var opt_only_parse: OptionBool = new OptionBool("Only proceed to parse step of loaders", "--only-parse")
+	var opt_only_parse = new OptionBool("Only proceed to parse step of loaders", "--only-parse")
+
+	# Option --ignore-visibility
+	var opt_ignore_visibility = new OptionBool("Do not check, and produce errors, on visibility issues.", "--ignore-visibility")
 
 	redef init
 	do
 		super
-		option_context.add_option(opt_path, opt_only_parse, opt_only_metamodel)
+		option_context.add_option(opt_path, opt_only_parse, opt_only_metamodel, opt_ignore_visibility)
 	end
 
+	# The modelbuilder 1-to-1 associated with the toolcontext
 	fun modelbuilder: ModelBuilder do return modelbuilder_real.as(not null)
+
 	private var modelbuilder_real: nullable ModelBuilder = null
 
-	fun run_global_phases(mainmodule: MModule)
+	# Combine module to make a single one if required.
+	fun make_main_module(mmodules: Array[MModule]): MModule
+	do
+		assert not mmodules.is_empty
+		var mainmodule
+		if mmodules.length == 1 then
+			mainmodule = mmodules.first
+		else
+			# We need a main module, so we build it by importing all modules
+			mainmodule = new MModule(modelbuilder.model, null, mmodules.first.name + "-m", new Location(mmodules.first.location.file, 0, 0, 0, 0))
+			mainmodule.is_fictive = true
+			mainmodule.set_imported_mmodules(mmodules)
+		end
+		return mainmodule
+	end
+
+	# Run `process_mainmodule` on all phases
+	fun run_global_phases(mmodules: Array[MModule])
 	do
+		var mainmodule = make_main_module(mmodules)
 		for phase in phases_list do
-			phase.process_mainmodule(mainmodule)
+			if phase.disabled then continue
+			phase.process_mainmodule(mainmodule, mmodules)
 		end
 	end
 end
 
 redef class Phase
-	# Specific action to execute on the whole program
-	# Called by the `ToolContext::run_global_phases`
+	# Specific action to execute on the whole program.
+	# Called by the `ToolContext::run_global_phases`.
+	#
+	# `mainmodule` is the main module of the program.
+	# It could be an implicit module (called like the first given_mmodules).
+	#
+	# `given_modules` is the list of explicitely requested modules.
+	# from the command-line for instance.
+	#
+	# REQUIRE: `not given_modules.is_empty`
+	# REQUIRE: `(given_modules.length == 1) == (mainmodule == given_modules.first)`
+	#
 	# @toimplement
-	fun process_mainmodule(mainmodule: MModule) do end
+	fun process_mainmodule(mainmodule: MModule, given_mmodules: SequenceRead[MModule]) do end
 end
 
 
@@ -95,10 +125,8 @@ class ModelBuilder
 
 	# Instantiate a modelbuilder for a model and a toolcontext
 	# Important, the options of the toolcontext must be correctly set (parse_option already called)
-	init(model: Model, toolcontext: ToolContext)
+	init
 	do
-		self.model = model
-		self.toolcontext = toolcontext
 		assert toolcontext.modelbuilder_real == null
 		toolcontext.modelbuilder_real = self
 
@@ -110,14 +138,9 @@ class ModelBuilder
 			paths.append(path_env.split_with(':'))
 		end
 
-		path_env = "NIT_DIR".environ
-		if not path_env.is_empty then
-			var libname = "{path_env}/lib"
-			if libname.file_exists then paths.add(libname)
-		end
-
-		var libname = "{sys.program_name.dirname}/../lib"
-		if libname.file_exists then paths.add(libname.simplify_path)
+		var nit_dir = toolcontext.nit_dir
+		var libname = "{nit_dir}/lib"
+		if libname.file_exists then paths.add(libname)
 	end
 
 	# Load a bunch of modules.
@@ -198,37 +221,70 @@ class ModelBuilder
 		for mprop in props do
 			if not mtype.has_mproperty(mmodule, mprop) then continue
 			if not mmodule.is_visible(mprop.intro_mclassdef.mmodule, mprop.visibility) then continue
+
+			# new-factories are invisible outside of the class
+			if mprop isa MMethod and mprop.is_new and (not mtype isa MClassType or mprop.intro_mclassdef.mclass != mtype.mclass) then
+				continue
+			end
+
 			if res == null then
 				res = mprop
-			else
+				continue
+			end
+
+			# Two global properties?
+			# First, special case for init, keep the most specific ones
+			if res isa MMethod and mprop isa MMethod and res.is_init and mprop.is_init then
 				var restype = res.intro_mclassdef.bound_mtype
 				var mproptype = mprop.intro_mclassdef.bound_mtype
-				if restype.is_subtype(mmodule, null, mproptype) then
-					# we keep res
-				else if mproptype.is_subtype(mmodule, null, restype) then
+				if mproptype.is_subtype(mmodule, null, restype) then
+					# found a most specific constructor, so keep it
 					res = mprop
-				else
-					if ress == null then ress = new Array[MProperty]
-					ress.add(mprop)
+					continue
 				end
 			end
+
+			# Ok, just keep all prop in the ress table
+			if ress == null then
+				ress = new Array[MProperty]
+				ress.add(res)
+			end
+			ress.add(mprop)
 		end
-		if ress != null then
+
+		# There is conflict?
+		if ress != null and res isa MMethod and res.is_init then
+			# special case forinit again
 			var restype = res.intro_mclassdef.bound_mtype
+			var ress2 = new Array[MProperty]
 			for mprop in ress do
 				var mproptype = mprop.intro_mclassdef.bound_mtype
 				if not restype.is_subtype(mmodule, null, mproptype) then
-					self.error(anode, "Ambigous property name '{name}' for {mtype}; conflict between {mprop.full_name} and {res.full_name}")
-					return null
+					ress2.add(mprop)
+				else if not mprop isa MMethod or not mprop.is_init then
+					ress2.add(mprop)
 				end
 			end
+			if ress2.is_empty then
+				ress = null
+			else
+				ress = ress2
+				ress.add(res)
+			end
+		end
+
+		if ress != null then
+			assert ress.length > 1
+			var s = new Array[String]
+			for mprop in ress do s.add mprop.full_name
+			self.error(anode, "Ambigous property name '{name}' for {mtype}; conflict between {s.join(" and ")}")
 		end
 
 		self.try_get_mproperty_by_name2_cache[mmodule, mtype, name] = res
 		return res
 	end
 
-	private var try_get_mproperty_by_name2_cache: HashMap3[MModule, MType, String, nullable MProperty] = new HashMap3[MModule, MType, String, nullable MProperty]
+	private var try_get_mproperty_by_name2_cache = new HashMap3[MModule, MType, String, nullable MProperty]
 
 
 	# Alias for try_get_mproperty_by_name2(anode, mclassdef.mmodule, mclassdef.mtype, name)
@@ -241,57 +297,46 @@ class ModelBuilder
 	# The list is initially set with :
 	#   * the toolcontext --path option
 	#   * the NIT_PATH environment variable
-	#   * some heuristics including the NIT_DIR environment variable and the progname of the process
+	#   * `toolcontext.nit_dir`
 	# Path can be added (or removed) by the client
-	var paths: Array[String] = new Array[String]
+	var paths = new Array[String]
 
-	# Get a module by its short name; if required, the module is loaded, parsed and its hierarchies computed.
-	# If `mmodule` is set, then the module search starts from it up to the top level (see `paths`);
-	# if `mmodule` is null then the module is searched in the top level only.
-	# If no module exists or there is a name conflict, then an error on `anode` is displayed and null is returned.
-	# FIXME: add a way to handle module name conflict
-	fun get_mmodule_by_name(anode: ANode, mmodule: nullable MModule, name: String): nullable MModule
+	# Like (an used by) `get_mmodule_by_name` but just return the ModulePath
+	private fun search_mmodule_by_name(anode: ANode, mgroup: nullable MGroup, name: String): nullable ModulePath
 	do
-		# what path where tried to display on error message
-		var tries = new Array[String]
-
-		# First, look in groups of the module
-		if mmodule != null then
-			var mgroup = mmodule.mgroup
-			while mgroup != null do
-				var dirname = mgroup.filepath
-				if dirname == null then break # virtual group
-				if dirname.has_suffix(".nit") then break # singleton project
-
-				# Second, try the directory to find a file
-				var try_file = dirname + "/" + name + ".nit"
-				tries.add try_file
-				if try_file.file_exists then
-					var res = self.load_module(try_file.simplify_path)
-					if res == null then return null # Forward error
-					return res.mmodule.as(not null)
-				end
-
-				# Third, try if the requested module is itself a group
-				try_file = dirname + "/" + name + "/" + name + ".nit"
-				if try_file.file_exists then
-					mgroup = get_mgroup(dirname + "/" + name)
-					var res = self.load_module(try_file.simplify_path)
-					if res == null then return null # Forward error
-					return res.mmodule.as(not null)
-				end
+		# First, look in groups
+		var c = mgroup
+		while c != null do
+			var dirname = c.filepath
+			if dirname == null then break # virtual group
+			if dirname.has_suffix(".nit") then break # singleton project
+
+			# Second, try the directory to find a file
+			var try_file = dirname + "/" + name + ".nit"
+			if try_file.file_exists then
+				var res = self.identify_file(try_file.simplify_path)
+				assert res != null
+				return res
+			end
 
-				mgroup = mgroup.parent
+			# Third, try if the requested module is itself a group
+			try_file = dirname + "/" + name + "/" + name + ".nit"
+			if try_file.file_exists then
+				var res = self.identify_file(try_file.simplify_path)
+				assert res != null
+				return res
 			end
+
+			c = c.parent
 		end
 
 		# Look at some known directories
 		var lookpaths = self.paths
 
-		# Look in the directory of module project also (even if not explicitely in the path)
-		if mmodule != null and mmodule.mgroup != null then
+		# Look in the directory of the group project also (even if not explicitely in the path)
+		if mgroup != null then
 			# path of the root group
-			var dirname = mmodule.mgroup.mproject.root.filepath
+			var dirname = mgroup.mproject.root.filepath
 			if dirname != null then
 				dirname = dirname.join_path("..").simplify_path
 				if not lookpaths.has(dirname) and dirname.file_exists then
@@ -301,10 +346,39 @@ class ModelBuilder
 			end
 		end
 
+		var candidate = search_module_in_paths(anode.hot_location, name, lookpaths)
+
+		if candidate == null then
+			if mgroup != null then
+				error(anode, "Error: cannot find module {name} from {mgroup.name}. tried {lookpaths.join(", ")}")
+			else
+				error(anode, "Error: cannot find module {name}. tried {lookpaths.join(", ")}")
+			end
+			return null
+		end
+		return candidate
+	end
+
+	# Get a module by its short name; if required, the module is loaded, parsed and its hierarchies computed.
+	# If `mgroup` is set, then the module search starts from it up to the top level (see `paths`);
+	# if `mgroup` is null then the module is searched in the top level only.
+	# 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: 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
+		var res = self.load_module(path.filepath)
+		if res == null then return null # Forward error
+		return res.mmodule.as(not null)
+	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
+	do
 		var candidate: nullable String = null
 		for dirname in lookpaths do
 			var try_file = (dirname + "/" + name + ".nit").simplify_path
-			tries.add try_file
 			if try_file.file_exists then
 				if candidate == null then
 					candidate = try_file
@@ -313,7 +387,7 @@ class ModelBuilder
 					var abs_candidate = module_absolute_path(candidate)
 					var abs_try_file = module_absolute_path(try_file)
 					if abs_candidate != abs_try_file then
-						error(anode, "Error: conflicting module file for {name}: {candidate} {try_file}")
+						toolcontext.error(location, "Error: conflicting module file for {name}: {candidate} {try_file}")
 					end
 				end
 			end
@@ -326,22 +400,13 @@ class ModelBuilder
 					var abs_candidate = module_absolute_path(candidate)
 					var abs_try_file = module_absolute_path(try_file)
 					if abs_candidate != abs_try_file then
-						error(anode, "Error: conflicting module file for {name}: {candidate} {try_file}")
+						toolcontext.error(location, "Error: conflicting module file for {name}: {candidate} {try_file}")
 					end
 				end
 			end
 		end
-		if candidate == null then
-			if mmodule != null then
-				error(anode, "Error: cannot find module {name} from {mmodule}. tried {tries.join(", ")}")
-			else
-				error(anode, "Error: cannot find module {name}. tried {tries.join(", ")}")
-			end
-			return null
-		end
-		var res = self.load_module(candidate)
-		if res == null then return null # Forward error
-		return res.mmodule.as(not null)
+		if candidate == null then return null
+		return identify_file(candidate)
 	end
 
 	# cache for `identify_file` by realpath
@@ -351,9 +416,27 @@ class ModelBuilder
 	# Load the associated project and groups if required
 	private fun identify_file(path: String): nullable ModulePath
 	do
-		if not path.file_exists then
-			toolcontext.error(null, "Error: `{path}` does not exists")
-			return null
+		# special case for not a nit file
+		if path.file_extension != "nit" then
+			# search in known -I paths
+			var res = search_module_in_paths(null, path, self.paths)
+			if res != null then return res
+
+			# Found nothins? maybe it is a group...
+			var candidate = null
+			if path.file_exists then
+				var mgroup = get_mgroup(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
+			end
+
+			if candidate == null then
+				toolcontext.error(null, "Error: cannot find module `{path}`.")
+				return null
+			end
+			path = candidate
 		end
 
 		# Fast track, the path is already known
@@ -375,6 +458,7 @@ class ModelBuilder
 		end
 
 		var res = new ModulePath(pn, path, mgroup)
+		mgroup.module_paths.add(res)
 
 		identified_files[rp] = res
 		return res
@@ -392,11 +476,22 @@ class ModelBuilder
 			return mgroups[rdp]
 		end
 
-		# Hack, a dir is determined by the presence of a honomymous nit file
+		# Hack, a group is determined by:
+		# * the presence of a honomymous nit file
+		# * the fact that the directory is named `src`
 		var pn = rdp.basename(".nit")
 		var mp = dirpath.join_path(pn + ".nit").simplify_path
 
-		if not mp.file_exists then return null
+		var dirpath2 = dirpath
+		if not mp.file_exists then
+			if pn == "src" then
+				# With a src directory, the group name is the name of the parent directory
+				dirpath2 = rdp.dirname
+				pn = dirpath2.basename("")
+			else
+				return null
+			end
+		end
 
 		# check parent directory
 		var parentpath = dirpath.join_path("..").simplify_path
@@ -413,6 +508,17 @@ class ModelBuilder
 			mgroup = new MGroup(pn, parent.mproject, parent)
 			toolcontext.info("found sub group `{mgroup.full_name}` at {dirpath}", 2)
 		end
+		var readme = dirpath2.join_path("README.md")
+		if not readme.file_exists then readme = dirpath2.join_path("README")
+		if readme.file_exists then
+			var mdoc = new MDoc
+			var s = new IFStream.open(readme)
+			while not s.eof do
+				mdoc.content.add(s.read_line)
+			end
+			mgroup.mdoc = mdoc
+			mdoc.original_mentity = mgroup
+		end
 		mgroup.filepath = dirpath
 		mgroups[rdp] = mgroup
 		return mgroup
@@ -444,7 +550,6 @@ class ModelBuilder
 		var parser = new Parser(lexer)
 		var tree = parser.parse
 		file.close
-		var mod_name = filename.basename(".nit")
 
 		# Handle lexer and parser error
 		var nmodule = tree.n_base
@@ -474,7 +579,7 @@ class ModelBuilder
 		end
 
 		# Load it manually
-		var nmodule = load_module_ast(filename)
+		var nmodule = load_module_ast(file.filepath)
 		if nmodule == null then return null # forward error
 
 		# build the mmodule and load imported modules
@@ -485,29 +590,38 @@ class ModelBuilder
 		# Update the file information
 		file.mmodule = mmodule
 
+		# Load imported module
+		build_module_importation(nmodule)
+
 		return nmodule
 	end
 
-	fun load_rt_module(parent: MModule, nmodule: AModule, mod_name: String): nullable AModule
+	# Injection of a new module without source.
+	# Used by the interpreted
+	fun load_rt_module(parent: nullable MModule, nmodule: AModule, mod_name: String): nullable AModule
 	do
 		# Create the module
-		var mmodule = new MModule(model, parent.mgroup, mod_name, nmodule.location)
+
+		var mgroup = null
+		if parent != null then mgroup = parent.mgroup
+		var mmodule = new MModule(model, mgroup, mod_name, nmodule.location)
 		nmodule.mmodule = mmodule
 		nmodules.add(nmodule)
 		self.mmodule2nmodule[mmodule] = nmodule
 
-		var imported_modules = new Array[MModule]
-
-		imported_modules.add(parent)
-		mmodule.set_visibility_for(parent, intrude_visibility)
-
-		mmodule.set_imported_mmodules(imported_modules)
+		if parent!= null then
+			var imported_modules = new Array[MModule]
+			imported_modules.add(parent)
+			mmodule.set_visibility_for(parent, intrude_visibility)
+			mmodule.set_imported_mmodules(imported_modules)
+		else
+			build_module_importation(nmodule)
+		end
 
 		return nmodule
 	end
 
 	# Visit the AST and create the `MModule` object
-	# Then, recursively load imported modules
 	private fun build_a_mmodule(mgroup: nullable MGroup, mod_name: String, nmodule: AModule): nullable MModule
 	do
 		# Check the module name
@@ -527,7 +641,16 @@ class ModelBuilder
 		nmodules.add(nmodule)
 		self.mmodule2nmodule[mmodule] = nmodule
 
-		build_module_importation(nmodule)
+		if decl != null then
+			var ndoc = decl.n_doc
+			if ndoc != null then
+				var mdoc = ndoc.to_mdoc
+				mmodule.mdoc = mdoc
+				mdoc.original_mentity = mmodule
+			else
+				advice(decl, "missing-doc", "Documentation warning: Undocumented module `{mmodule}`")
+			end
+		end
 
 		return mmodule
 	end
@@ -545,8 +668,15 @@ class ModelBuilder
 			if not aimport isa AStdImport then
 				continue
 			end
+			var mgroup = mmodule.mgroup
+			if aimport.n_name.n_quad != null then mgroup = null # Start from top level
+			for grp in aimport.n_name.n_path do
+				var path = search_mmodule_by_name(grp, mgroup, grp.text)
+				if path == null then return # Skip error
+				mgroup = path.mgroup
+			end
 			var mod_name = aimport.n_name.n_id.text
-			var sup = self.get_mmodule_by_name(aimport.n_name, mmodule, mod_name)
+			var sup = self.get_mmodule_by_name(aimport.n_name, mgroup, mod_name)
 			if sup == null then continue # Skip error
 			aimport.mmodule = sup
 			imported_modules.add(sup)
@@ -555,6 +685,13 @@ class ModelBuilder
 				error(aimport.n_visibility, "Error: only properties can be protected.")
 				return
 			end
+			if sup == mmodule then
+				error(aimport.n_name, "Error: Dependency loop in module {mmodule}.")
+			end
+			if sup.in_importation < mmodule then
+				error(aimport.n_name, "Error: Dependency loop between modules {mmodule} and {sup}.")
+				return
+			end
 			mmodule.set_visibility_for(sup, mvisibility)
 		end
 		if stdimport then
@@ -567,14 +704,33 @@ class ModelBuilder
 		end
 		self.toolcontext.info("{mmodule} imports {imported_modules.join(", ")}", 3)
 		mmodule.set_imported_mmodules(imported_modules)
+
+		# Force standard to be public if imported
+		for sup in mmodule.in_importation.greaters do
+			if sup.name == "standard" then
+				mmodule.set_visibility_for(sup, public_visibility)
+			end
+		end
+
+		# TODO: Correctly check for useless importation
+		# It is even doable?
+		var directs = mmodule.in_importation.direct_greaters
+		for nim in nmodule.n_imports do
+			if not nim isa AStdImport then continue
+			var im = nim.mmodule
+			if im == null then continue
+			if directs.has(im) then continue
+			# This generates so much noise that it is simpler to just comment it
+			#warning(nim, "Warning: possible useless importation of {im}")
+		end
 	end
 
 	# All the loaded modules
-	var nmodules: Array[AModule] = new Array[AModule]
+	var nmodules = new Array[AModule]
 
 	# Register the nmodule associated to each mmodule
 	# FIXME: why not refine the `MModule` class with a nullable attribute?
-	var mmodule2nmodule: HashMap[MModule, AModule] = new HashMap[MModule, AModule]
+	var mmodule2nmodule = new HashMap[MModule, AModule]
 
 	# Helper function to display an error on a node.
 	# Alias for `self.toolcontext.error(n.hot_location, text)`
@@ -585,17 +741,26 @@ class ModelBuilder
 
 	# Helper function to display a warning on a node.
 	# Alias for: `self.toolcontext.warning(n.hot_location, text)`
-	fun warning(n: ANode, text: String)
+	fun warning(n: ANode, tag, text: String)
 	do
-		self.toolcontext.warning(n.hot_location, text)
+		self.toolcontext.warning(n.hot_location, tag, text)
+	end
+
+	# Helper function to display an advice on a node.
+	# Alias for: `self.toolcontext.advice(n.hot_location, text)`
+	fun advice(n: ANode, tag, text: String)
+	do
+		self.toolcontext.advice(n.hot_location, tag, text)
 	end
 
 	# Force to get the primitive method named `name` on the type `recv` or do a fatal error on `n`
-	fun force_get_primitive_method(n: ANode, name: String, recv: MClass, mmodule: MModule): MMethod
+	fun force_get_primitive_method(n: nullable ANode, name: String, recv: MClass, mmodule: MModule): MMethod
 	do
 		var res = mmodule.try_get_primitive_method(name, recv)
 		if res == null then
-			self.toolcontext.fatal_error(n.hot_location, "Fatal Error: {recv} must have a property named {name}.")
+			var l = null
+			if n != null then l = n.hot_location
+			self.toolcontext.fatal_error(l, "Fatal Error: {recv} must have a property named {name}.")
 			abort
 		end
 		return res
@@ -620,6 +785,10 @@ private class ModulePath
 	redef fun to_s do return filepath
 end
 
+redef class MGroup
+	# modules paths associated with the group
+	private var module_paths = new Array[ModulePath]
+end
 
 redef class AStdImport
 	# The imported module once determined
@@ -649,3 +818,30 @@ end
 redef class APrivateVisibility
 	redef fun mvisibility do return private_visibility
 end
+
+redef class ADoc
+	private var mdoc_cache: nullable MDoc
+	fun to_mdoc: MDoc
+	do
+		var res = mdoc_cache
+		if res != null then return res
+		res = new MDoc
+		for c in n_comment do
+			var text = c.text
+			if text.length < 2 then
+				res.content.add ""
+				continue
+			end
+			assert text.chars[0] == '#'
+			if text.chars[1] == ' ' then
+				text = text.substring_from(2) # eat starting `#` and space
+			else
+				text = text.substring_from(1) # eat atarting `#` only
+			end
+			if text.chars.last == '\n' then text = text.substring(0, text.length-1) # drop \n
+			res.content.add(text)
+		end
+		mdoc_cache = res
+		return res
+	end
+end