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

diff --git a/src/compiler/separate_compiler.nit b/src/compiler/separate_compiler.nit
index 7eed804..c298f93 100644
--- a/src/compiler/separate_compiler.nit
+++ b/src/compiler/separate_compiler.nit
@@ -90,45 +90,7 @@ redef class ModelBuilder
 		self.toolcontext.info("*** GENERATING C ***", 1)
 
 		var compiler = new SeparateCompiler(mainmodule, self, runtime_type_analysis)
-		compiler.compile_header
-
-		# compile class structures
-		self.toolcontext.info("Property coloring", 2)
-		compiler.new_file("{mainmodule.name}.classes")
-		compiler.do_property_coloring
-		for m in mainmodule.in_importation.greaters do
-			for mclass in m.intro_mclasses do
-				if mclass.kind == abstract_kind or mclass.kind == interface_kind then continue
-				compiler.compile_class_to_c(mclass)
-			end
-		end
-
-		# The main function of the C
-		compiler.new_file("{mainmodule.name}.main")
-		compiler.compile_nitni_global_ref_functions
-		compiler.compile_main_function
-		compiler.compile_finalizer_function
-
-		# compile methods
-		for m in mainmodule.in_importation.greaters do
-			self.toolcontext.info("Generate C for module {m}", 2)
-			compiler.new_file("{m.name}.sep")
-			compiler.compile_module_to_c(m)
-		end
-
-		# compile live & cast type structures
-		self.toolcontext.info("Type coloring", 2)
-		compiler.new_file("{mainmodule.name}.types")
-		var mtypes = compiler.do_type_coloring
-		for t in mtypes do
-			compiler.compile_type_to_c(t)
-		end
-		# compile remaining types structures (useless but needed for the symbol resolution at link-time)
-		for t in compiler.undead_types do
-			if mtypes.has(t) then continue
-			compiler.compile_type_to_c(t)
-		end
-
+		compiler.do_compilation
 		compiler.display_stats
 
 		var time1 = get_time
@@ -156,20 +118,72 @@ class SeparateCompiler
 	private var undead_types: Set[MType] = new HashSet[MType]
 	private var live_unresolved_types: Map[MClassDef, Set[MType]] = new HashMap[MClassDef, HashSet[MType]]
 
-	private var type_ids: Map[MType, Int]
-	private var type_colors: Map[MType, Int]
-	private var opentype_colors: Map[MType, Int]
-	protected var method_colors: Map[PropertyLayoutElement, Int]
-	protected var attr_colors: Map[MAttribute, Int]
+	private var type_ids: Map[MType, Int] is noinit
+	private var type_colors: Map[MType, Int] is noinit
+	private var opentype_colors: Map[MType, Int] is noinit
+	protected var method_colors: Map[PropertyLayoutElement, Int] is noinit
+	protected var attr_colors: Map[MAttribute, Int] is noinit
 
-	init(mainmodule: MModule, mmbuilder: ModelBuilder, runtime_type_analysis: nullable RapidTypeAnalysis) do
-		super(mainmodule, mmbuilder)
+	init do
 		var file = new_file("nit.common")
 		self.header = new CodeWriter(file)
-		self.runtime_type_analysis = runtime_type_analysis
 		self.compile_box_kinds
 	end
 
+	redef fun do_compilation
+	do
+		var compiler = self
+		compiler.compile_header
+
+		var c_name = mainmodule.c_name
+
+		# compile class structures
+		modelbuilder.toolcontext.info("Property coloring", 2)
+		compiler.new_file("{c_name}.classes")
+		compiler.do_property_coloring
+		for m in mainmodule.in_importation.greaters do
+			for mclass in m.intro_mclasses do
+				#if mclass.kind == abstract_kind or mclass.kind == interface_kind then continue
+				compiler.compile_class_to_c(mclass)
+			end
+		end
+
+		# The main function of the C
+		compiler.new_file("{c_name}.main")
+		compiler.compile_nitni_global_ref_functions
+		compiler.compile_main_function
+		compiler.compile_finalizer_function
+
+		# compile methods
+		for m in mainmodule.in_importation.greaters do
+			modelbuilder.toolcontext.info("Generate C for module {m.full_name}", 2)
+			compiler.new_file("{m.c_name}.sep")
+			compiler.compile_module_to_c(m)
+		end
+
+		# compile live & cast type structures
+		modelbuilder.toolcontext.info("Type coloring", 2)
+		compiler.new_file("{c_name}.types")
+		compiler.compile_types
+	end
+
+	# Color and compile type structures and cast information
+	fun compile_types
+	do
+		var compiler = self
+
+		var mtypes = compiler.do_type_coloring
+		for t in mtypes do
+			compiler.compile_type_to_c(t)
+		end
+		# compile remaining types structures (useless but needed for the symbol resolution at link-time)
+		for t in compiler.undead_types do
+			if mtypes.has(t) then continue
+			compiler.compile_type_to_c(t)
+		end
+
+	end
+
 	redef fun compile_header_structs do
 		self.header.add_decl("typedef void(*nitmethod_t)(void); /* general C type representing a Nit method. */")
 		self.compile_header_attribute_structs
@@ -418,13 +432,12 @@ class SeparateCompiler
 		var live_cast_types = runtime_type_analysis.live_cast_types
 		var mtypes = new HashSet[MType]
 		mtypes.add_all(live_types)
-		mtypes.add_all(live_cast_types)
 		for c in self.box_kinds.keys do
 			mtypes.add(c.mclass_type)
 		end
 
 		# Compute colors
-		var poset = poset_from_mtypes(mtypes)
+		var poset = poset_from_mtypes(mtypes, live_cast_types)
 		var colorer = new POSetColorer[MType]
 		colorer.colorize(poset)
 		type_ids = colorer.ids
@@ -437,12 +450,13 @@ class SeparateCompiler
 		return poset
 	end
 
-	private fun poset_from_mtypes(mtypes: Set[MType]): POSet[MType] do
+	private fun poset_from_mtypes(mtypes, cast_types: Set[MType]): POSet[MType] do
 		var poset = new POSet[MType]
 		for e in mtypes do
 			poset.add_node(e)
-			for o in mtypes do
+			for o in cast_types do
 				if e == o then continue
+				poset.add_node(o)
 				if e.is_subtype(mainmodule, null, o) then
 					poset.add_edge(e, o)
 				end
@@ -1068,7 +1082,6 @@ class SeparateCompilerVisitor
 			var tgs = rta.live_targets(callsite)
 			if tgs.length == 1 then
 				# DIRECT CALL
-				self.varargize(mmethod.intro, mmethod.intro.msignature.as(not null), args)
 				var res0 = before_send(mmethod, args)
 				var res = call(tgs.first, tgs.first.mclassdef.bound_mtype, args)
 				if res0 != null then
@@ -1084,8 +1097,6 @@ class SeparateCompilerVisitor
 	end
 	redef fun send(mmethod, arguments)
 	do
-		self.varargize(mmethod.intro, mmethod.intro.msignature.as(not null), arguments)
-
 		if arguments.first.mcasttype.ctype != "val*" then
 			# In order to shortcut the primitive, we need to find the most specific method
 			# Howverr, because of performance (no flattening), we always work on the realmainmodule
@@ -1175,10 +1186,7 @@ class SeparateCompilerVisitor
 		var res: nullable RuntimeVariable
 		var msignature = mmethod.intro.msignature.resolve_for(mmethod.intro.mclassdef.bound_mtype, mmethod.intro.mclassdef.bound_mtype, mmethod.intro.mclassdef.mmodule, true)
 		var ret = msignature.return_mtype
-		if mmethod.is_new then
-			ret = arguments.first.mtype
-			res = self.new_var(ret)
-		else if ret == null then
+		if ret == null then
 			res = null
 		else
 			res = self.new_var(ret)
@@ -1229,10 +1237,7 @@ class SeparateCompilerVisitor
 
 		var res: nullable RuntimeVariable
 		var ret = mmethoddef.msignature.return_mtype
-		if mmethoddef.mproperty.is_new then
-			ret = arguments.first.mtype
-			res = self.new_var(ret)
-		else if ret == null then
+		if ret == null then
 			res = null
 		else
 			ret = ret.resolve_for(mmethoddef.mclassdef.bound_mtype, mmethoddef.mclassdef.bound_mtype, mmethoddef.mclassdef.mmodule, true)
@@ -1825,9 +1830,6 @@ class SeparateRuntimeFunction
 		var ret = msignature.return_mtype
 		if ret != null then
 			sig.append("{ret.ctype} ")
-		else if mmethoddef.mproperty.is_new then
-			ret = recv
-			sig.append("{ret.ctype} ")
 		else
 			sig.append("void ")
 		end
@@ -1902,9 +1904,6 @@ class VirtualRuntimeFunction
 		var ret = msignature.return_mtype
 		if ret != null then
 			sig.append("{ret.ctype} ")
-		else if mmethoddef.mproperty.is_new then
-			ret = recv
-			sig.append("{ret.ctype} ")
 		else
 			sig.append("void ")
 		end