rta: store real types in live_cast_type

[nit.git] / src / separate_erasure_compiler.nit

diff --git a/src/separate_erasure_compiler.nit b/src/separate_erasure_compiler.nit
index d8bb170..a5d353d 100644 (file)
--- a/src/separate_erasure_compiler.nit
+++ b/src/separate_erasure_compiler.nit
@@ -32,15 +32,16 @@ redef class ToolContext
 end
 
 redef class ModelBuilder
-       fun run_separate_erasure_compiler(mainmodule: MModule, runtime_type_analysis: RapidTypeAnalysis)
+       fun run_separate_erasure_compiler(mainmodule: MModule, runtime_type_analysis: nullable RapidTypeAnalysis)
        do
                var time0 = get_time
-               self.toolcontext.info("*** COMPILING TO C ***", 1)
+               self.toolcontext.info("*** GENERATING C ***", 1)
 
                var compiler = new SeparateErasureCompiler(mainmodule, self, runtime_type_analysis)
                compiler.compile_header
 
                # compile class structures
+               self.toolcontext.info("Property coloring", 2)
                compiler.new_file("{mainmodule.name}.tables")
                compiler.do_property_coloring
                for m in mainmodule.in_importation.greaters do
@@ -56,12 +57,15 @@ redef class ModelBuilder
 
                # 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
 
                compiler.display_stats
 
+               var time1 = get_time
+               self.toolcontext.info("*** END GENERATING C: {time1-time0} ***", 2)
                write_and_make(compiler)
        end
 end
@@ -72,27 +76,42 @@ class SeparateErasureCompiler
        private var class_layout: nullable Layout[MClass]
        protected var vt_layout: nullable Layout[MVirtualTypeProp]
 
-       init(mainmodule: MModule, mmbuilder: ModelBuilder, runtime_type_analysis: RapidTypeAnalysis) do
+       init(mainmodule: MModule, mmbuilder: ModelBuilder, runtime_type_analysis: nullable RapidTypeAnalysis) do
                super
 
                var mclasses = new HashSet[MClass].from(mmbuilder.model.mclasses)
 
                var layout_builder: TypingLayoutBuilder[MClass]
+               var class_colorer = new MClassColorer(mainmodule)
                if modelbuilder.toolcontext.opt_phmod_typing.value then
                        layout_builder = new MClassHasher(new PHModOperator, mainmodule)
+                       class_colorer.build_layout(mclasses)
                else if modelbuilder.toolcontext.opt_phand_typing.value then
                        layout_builder = new MClassHasher(new PHAndOperator, mainmodule)
+                       class_colorer.build_layout(mclasses)
                else if modelbuilder.toolcontext.opt_bm_typing.value then
                        layout_builder = new MClassBMizer(mainmodule)
+                       class_colorer.build_layout(mclasses)
                else
-                       layout_builder = new MClassColorer(mainmodule)
+                       layout_builder = class_colorer
                end
                self.class_layout = layout_builder.build_layout(mclasses)
                self.class_tables = self.build_class_typing_tables(mclasses)
 
+               # lookup vt to build layout with
+               var vts = new HashMap[MClass, Set[MVirtualTypeProp]]
+               for mclass in mclasses do
+                       vts[mclass] = new HashSet[MVirtualTypeProp]
+                       for mprop in self.mainmodule.properties(mclass) do
+                               if mprop isa MVirtualTypeProp then
+                                       vts[mclass].add(mprop)
+                               end
+                       end
+               end
+
                # vt coloration
-               var vt_coloring = new MVirtualTypePropColorer(mainmodule)
-               var vt_layout = vt_coloring.build_layout(mclasses)
+               var vt_coloring = new MPropertyColorer[MVirtualTypeProp](mainmodule, class_colorer)
+               var vt_layout = vt_coloring.build_layout(vts)
                self.vt_tables = build_vt_tables(mclasses, vt_layout)
                self.vt_layout = vt_layout
        end
@@ -102,9 +121,13 @@ class SeparateErasureCompiler
                for mclass in mclasses do
                        var table = new Array[nullable MPropDef]
                        # first, fill table from parents by reverse linearization order
-                       var parents = self.mainmodule.super_mclasses(mclass)
-                       var lin = self.mainmodule.reverse_linearize_mclasses(parents)
-                       for parent in lin do
+                       var parents = new Array[MClass]
+                       if mainmodule.flatten_mclass_hierarchy.has(mclass) then
+                               parents = mclass.in_hierarchy(mainmodule).greaters.to_a
+                               self.mainmodule.linearize_mclasses(parents)
+                       end
+                       for parent in parents do
+                               if parent == mclass then continue
                                for mproperty in self.mainmodule.properties(parent) do
                                        if not mproperty isa MVirtualTypeProp then continue
                                        var color = layout.pos[mproperty]
@@ -147,9 +170,10 @@ class SeparateErasureCompiler
                var layout = self.class_layout
                for mclass in mclasses do
                        var table = new Array[nullable MClass]
-                       var supers = new HashSet[MClass]
-                       supers.add_all(self.mainmodule.super_mclasses(mclass))
-                       supers.add(mclass)
+                       var supers = new Array[MClass]
+                       if mainmodule.flatten_mclass_hierarchy.has(mclass) then
+                               supers = mclass.in_hierarchy(mainmodule).greaters.to_a
+                       end
                        for sup in supers do
                                var color: Int
                                if layout isa PHLayout[MClass, MClass] then
@@ -309,8 +333,6 @@ class SeparateErasureCompiler
                self.generate_init_attr(v, res, mtype)
                v.add("return {res};")
                v.add("\}")
-
-               generate_check_init_instance(mtype)
        end
 
        private fun build_class_vts_table(mclass: MClass): Bool do
@@ -580,7 +602,6 @@ class SeparateErasureCompilerVisitor
                end
                var length = self.int_instance(array.length)
                self.send(self.get_property("with_native", arraytype), [res, nat, length])
-               self.check_init_instance(res, arraytype)
                self.add("\}")
                return res
        end