nitg: better creation of varargs instances

[nit.git] / src / separate_compiler.nit

# This file is part of NIT ( http://www.nitlanguage.org ).
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

# Separate compilation of a Nit program
module separate_compiler


import global_compiler # TODO better separation of concerns
import coloring

redef class ToolContext
        # --separate
        var opt_separate: OptionBool = new OptionBool("Use separate compilation", "--separate")

        # --no-inline-intern
        var opt_no_inline_intern: OptionBool = new OptionBool("Do not inline call to intern methods", "--no-inline-intern")

        # --inline-coloring-numbers
        var opt_inline_coloring_numbers: OptionBool = new OptionBool("Inline colors and ids", "--inline-coloring-numbers")

        # --use-naive-coloring
        var opt_bm_typing: OptionBool = new OptionBool("Colorize items incrementaly, used to simulate binary matrix typing", "--bm-typing")

        # --use-mod-perfect-hashing
        var opt_phmod_typing: OptionBool = new OptionBool("Replace coloration by perfect hashing (with mod operator)", "--phmod-typing")

        # --use-and-perfect-hashing
        var opt_phand_typing: OptionBool = new OptionBool("Replace coloration by perfect hashing (with and operator)", "--phand-typing")

        # --generic-resolution-tree
        var opt_generic_tree: OptionBool = new OptionBool("Use tree representation for live generic types instead of flattened representation", "--generic-resolution-tree")

        redef init
        do
                super
                self.option_context.add_option(self.opt_separate)
                self.option_context.add_option(self.opt_no_inline_intern)
                self.option_context.add_option(self.opt_inline_coloring_numbers)
                self.option_context.add_option(self.opt_bm_typing)
                self.option_context.add_option(self.opt_phmod_typing)
                self.option_context.add_option(self.opt_phand_typing)
                self.option_context.add_option(self.opt_generic_tree)
        end
end

redef class ModelBuilder
        fun run_separate_compiler(mainmodule: MModule, runtime_type_analysis: RapidTypeAnalysis)
        do
                var time0 = get_time
                self.toolcontext.info("*** COMPILING TO C ***", 1)

                var compiler = new SeparateCompiler(mainmodule, runtime_type_analysis, self)

                # compile class structures
                for m in mainmodule.in_importation.greaters do
                        for mclass in m.intro_mclasses do
                                compiler.compile_class_to_c(mclass)
                        end
                end

                # The main function of the C
                compiler.compile_main_function

                # compile methods
                for m in mainmodule.in_importation.greaters do
                        compiler.compile_module_to_c(m)
                end

                # compile live & cast type structures
                var mtypes = compiler.do_type_coloring
                for t in mtypes do
                        compiler.compile_type_to_c(t)
                end

                if self.toolcontext.opt_generic_tree.value then
                        # compile live generic types selection structures
                        for mclass in model.mclasses do
                                compiler.compile_live_gentype_to_c(mclass)
                        end
                end

                write_and_make(compiler)
        end
end

# Singleton that store the knowledge about the separate compilation process
class SeparateCompiler
        super GlobalCompiler # TODO better separation of concerns

        private var undead_types: Set[MType] = new HashSet[MType]
        private var partial_types: Set[MType] = new HashSet[MType]
        protected var typeids: HashMap[MType, Int] protected writable = new HashMap[MType, Int]

        private var type_colors: Map[MType, Int] = typeids
        private var type_tables: nullable Map[MType, Array[nullable MType]] = null

        private var livetypes_colors: nullable Map[MType, Int]
        private var livetypes_tables: nullable Map[MClass, Array[nullable Object]]
        private var livetypes_tables_sizes: nullable Map[MClass, Array[Int]]
        private var live_unanchored_types: Map[MClassDef, Set[MType]] = new HashMap[MClassDef, HashSet[MType]]

        private var unanchored_types_colors: nullable Map[MType, Int]
        private var unanchored_types_tables: nullable Map[MClassType, Array[nullable MType]]
        private var unanchored_types_masks: nullable Map[MClassType, Int]

        protected var class_coloring: ClassColoring

        protected var method_colors: Map[MMethod, Int]
        protected var method_tables: Map[MClass, Array[nullable MMethodDef]]

        protected var attr_colors: Map[MAttribute, Int]
        protected var attr_tables: Map[MClass, Array[nullable MAttributeDef]]

        protected var vt_colors: Map[MVirtualTypeProp, Int]
        protected var vt_tables: Map[MClass, Array[nullable MVirtualTypeDef]]
        protected var vt_masks: nullable Map[MClass, Int]

        private var ft_colors: nullable Map[MParameterType, Int]
        private var ft_tables: nullable Map[MClass, Array[nullable MParameterType]]
        private var ft_masks: nullable Map[MClass, Int]

        init(mainmodule: MModule, runtime_type_analysis: RapidTypeAnalysis, mmbuilder: ModelBuilder) do
                self.do_property_coloring
                self.compile_box_kinds
        end

        redef fun compile_header_structs do
                self.header.add_decl("typedef void(*nitmethod_t)(void); /* general C type representing a Nit method. */")
                self.header.add_decl("typedef void* nitattribute_t; /* general C type representing a Nit attribute. */")
                self.header.add_decl("struct class \{ int box_kind; nitmethod_t vft[1]; \}; /* general C type representing a Nit class. */")

                if modelbuilder.toolcontext.opt_generic_tree.value then
                        # With generic_tree, only ft and vt resolution is stored in the type
                        self.header.add_decl("struct type \{ int id; const char *name; int color; short int is_nullable; int livecolor; struct types *vts_table; struct types *fts_table; int table_size; int type_table[1]; \}; /* general C type representing a Nit type. */")
                else
                        # With unanchored_table, all live type resolution are stored in a big table: unanchored_table
                        self.header.add_decl("struct type \{ int id; const char *name; int color; short int is_nullable; struct types *unanchored_table; int table_size; int type_table[1]; \}; /* general C type representing a Nit type. */")
                end

                if modelbuilder.toolcontext.opt_phmod_typing.value or modelbuilder.toolcontext.opt_phand_typing.value then
                        self.header.add_decl("struct types \{ int mask; struct type *types[1]; \}; /* a list types (used for vts, fts and unanchored lists). */")
                else
                        self.header.add_decl("struct types \{ struct type *types[1]; \}; /* a list types (used for vts, fts and unanchored lists). */")
                end


                self.header.add_decl("typedef struct \{ struct type *type; struct class *class; nitattribute_t attrs[1]; \} val; /* general C type representing a Nit instance. */")
        end

        redef fun compile_class_names do
                abort # There is no class name compilation since the name is stored in the type structure
        end

        fun compile_box_kinds
        do
                # Collect all bas box class
                # FIXME: this is not completely fine with a separate compilation scheme
                for classname in ["Int", "Bool", "Char", "Float", "NativeString", "Pointer"] do
                        var classes = self.mainmodule.model.get_mclasses_by_name(classname)
                        if classes == null then continue
                        assert classes.length == 1 else print classes.join(", ")
                        self.box_kinds[classes.first] = self.box_kinds.length + 1
                end
        end

        var box_kinds = new HashMap[MClass, Int]

        fun box_kind_of(mclass: MClass): Int
        do
                if mclass.mclass_type.ctype == "val*" then
                        return 0
                else if mclass.kind == extern_kind then
                        return self.box_kinds[self.mainmodule.get_primitive_class("Pointer")]
                else
                        return self.box_kinds[mclass]
                end

        end

        fun compile_color_consts(colors: Map[Object, Int]) do
                for m, c in colors do
                        if m isa MProperty then
                                if modelbuilder.toolcontext.opt_inline_coloring_numbers.value then
                                        self.header.add_decl("#define {m.const_color} {c}")
                                else
                                        self.header.add_decl("extern const int {m.const_color};")
                                        self.header.add("const int {m.const_color} = {c};")
                                end
                        else if m isa MType then
                                if modelbuilder.toolcontext.opt_inline_coloring_numbers.value then
                                        self.header.add_decl("#define {m.const_color} {c}")
                                else
                                        self.header.add_decl("extern const int {m.const_color};")
                                        self.header.add("const int {m.const_color} = {c};")
                                end
                        end
                end
        end

        # colorize classe properties
        fun do_property_coloring do

                # classes coloration
                self.class_coloring = new ClassColoring(mainmodule)
                class_coloring.colorize(modelbuilder.model.mclasses)

                # methods coloration
                var method_coloring = new MethodColoring(self.class_coloring)
                self.method_colors = method_coloring.colorize
                self.method_tables = method_coloring.build_property_tables
                self.compile_color_consts(self.method_colors)

                # attributes coloration
                var attribute_coloring = new AttributeColoring(self.class_coloring)
                self.attr_colors = attribute_coloring.colorize
                self.attr_tables = attribute_coloring.build_property_tables
                self.compile_color_consts(self.attr_colors)

                if modelbuilder.toolcontext.opt_bm_typing.value then
                        self.class_coloring = new NaiveClassColoring(mainmodule)
                        self.class_coloring.colorize(modelbuilder.model.mclasses)
                end

                # vt coloration
                if modelbuilder.toolcontext.opt_bm_typing.value then
                        var vt_coloring = new NaiveVTColoring(self.class_coloring)
                        self.vt_colors = vt_coloring.colorize
                        self.vt_tables = vt_coloring.build_property_tables
                else if modelbuilder.toolcontext.opt_phmod_typing.value then
                        var vt_coloring = new VTModPerfectHashing(self.class_coloring)
                        self.vt_colors = vt_coloring.colorize
                        self.vt_masks = vt_coloring.compute_masks
                        self.vt_tables = vt_coloring.build_property_tables
                else if modelbuilder.toolcontext.opt_phand_typing.value then
                        var vt_coloring = new VTAndPerfectHashing(self.class_coloring)
                        self.vt_colors = vt_coloring.colorize
                        self.vt_masks = vt_coloring.compute_masks
                        self.vt_tables = vt_coloring.build_property_tables
                else
                        var vt_coloring = new VTColoring(self.class_coloring)
                        self.vt_colors = vt_coloring.colorize
                        self.vt_tables = vt_coloring.build_property_tables
                end
                self.compile_color_consts(self.vt_colors)
        end

        # colorize live types of the program
        private fun do_type_coloring: Set[MType] do
                var mtypes = new HashSet[MType]
                mtypes.add_all(self.runtime_type_analysis.live_types)
                mtypes.add_all(self.runtime_type_analysis.live_cast_types)
                mtypes.add_all(self.undead_types)
                for c in self.box_kinds.keys do
                        mtypes.add(c.mclass_type)
                end

                for mtype in mtypes do
                        retieve_live_partial_types(mtype)
                end
                mtypes.add_all(self.partial_types)

                # set type unique id
                if modelbuilder.toolcontext.opt_phmod_typing.value or modelbuilder.toolcontext.opt_phand_typing.value then
                        var sorted_mtypes = new OrderedSet[MType].from(mtypes)
                        sorted_mtypes.linearize(new ReverseTypeSorter(self.mainmodule))
                        for mtype in sorted_mtypes do
                                self.typeids[mtype] = self.typeids.length + 1
                        end
                else
                        for mtype in mtypes do
                                self.typeids[mtype] = self.typeids.length
                        end
                end

                if modelbuilder.toolcontext.opt_generic_tree.value then
                        # fts coloration for non-erased compilation
                        if modelbuilder.toolcontext.opt_bm_typing.value then
                                var ft_coloring = new NaiveFTColoring(self.class_coloring)
                                self.ft_colors = ft_coloring.colorize
                                self.ft_tables = ft_coloring.build_ft_tables
                        else if modelbuilder.toolcontext.opt_phmod_typing.value then
                                var ft_coloring = new FTModPerfectHashing(self.class_coloring)
                                self.ft_colors = ft_coloring.colorize
                                self.ft_masks = ft_coloring.compute_masks
                                self.ft_tables = ft_coloring.build_ft_tables
                        else if modelbuilder.toolcontext.opt_phand_typing.value then
                                var ft_coloring = new FTAndPerfectHashing(self.class_coloring)
                                self.ft_colors = ft_coloring.colorize
                                self.ft_masks = ft_coloring.compute_masks
                                self.ft_tables = ft_coloring.build_ft_tables
                        else
                                var ft_coloring = new FTColoring(self.class_coloring)
                                self.ft_colors = ft_coloring.colorize
                                self.ft_tables = ft_coloring.build_ft_tables
                        end
                        self.compile_color_consts(self.ft_colors.as(not null))

                        # colorize live entries
                        var entries_coloring
                        if modelbuilder.toolcontext.opt_bm_typing.value then
                                entries_coloring = new NaiveLiveEntryColoring
                        else
                                entries_coloring = new LiveEntryColoring
                        end
                        self.livetypes_colors = entries_coloring.colorize(mtypes)
                        self.livetypes_tables = entries_coloring.build_livetype_tables(mtypes)
                        self.livetypes_tables_sizes = entries_coloring.livetypes_tables_sizes
                else
                        # VT and FT are stored with other unresolved types in the big unanchored_tables
                        self.compile_unanchored_tables(mtypes)
                end

                # colorize types
                if modelbuilder.toolcontext.opt_bm_typing.value then
                        var type_coloring = new NaiveTypeColoring(self.mainmodule, mtypes)
                        self.type_colors = type_coloring.colorize(mtypes)
                        self.type_tables = type_coloring.build_type_tables(mtypes, type_colors)
                else if modelbuilder.toolcontext.opt_phmod_typing.value then
                        var type_coloring = new TypeModPerfectHashing(self.mainmodule, mtypes)
                        self.type_colors = type_coloring.compute_masks(mtypes, typeids)
                        self.type_tables = type_coloring.hash_type_tables(mtypes, typeids, type_colors)
                        self.header.add_decl("#define HASH(mask, id) ((mask)%(id))")
                else if modelbuilder.toolcontext.opt_phand_typing.value then
                        var type_coloring = new TypeAndPerfectHashing(self.mainmodule, mtypes)
                        self.type_colors = type_coloring.compute_masks(mtypes, typeids)
                        self.type_tables = type_coloring.hash_type_tables(mtypes, typeids, type_colors)
                        self.header.add_decl("#define HASH(mask, id) ((mask)&(id))")
                else
                        var type_coloring = new TypeColoring(self.mainmodule, mtypes)
                        self.type_colors = type_coloring.colorize(mtypes)
                        self.type_tables = type_coloring.build_type_tables(mtypes, type_colors)
                end


                return mtypes
        end

        protected fun compile_unanchored_tables(mtypes: Set[MType]) do
                # Unanchored_tables is used to perform a type resolution at runtime in O(1)

                # During the visit of the body of classes, live_unanchored_types are collected
                # and associated to
                # Collect all live_unanchored_types (visited in the body of classes)

                # Determinate fo each livetype what are its possible requested anchored types
                var mtype2unanchored = new HashMap[MClassType, Set[MType]]
                for mtype in self.runtime_type_analysis.live_types do
                        var set = new HashSet[MType]
                        for cd in mtype.collect_mclassdefs(self.mainmodule) do
                                if self.live_unanchored_types.has_key(cd) then
                                        set.add_all(self.live_unanchored_types[cd])
                                end
                        end
                        mtype2unanchored[mtype] = set
                end

                # Compute the table layout with the prefered method
                if modelbuilder.toolcontext.opt_bm_typing.value then
                        var unanchored_type_coloring = new NaiveUnanchoredTypeColoring
                        self.unanchored_types_colors = unanchored_type_coloring.colorize(mtype2unanchored)
                        self.unanchored_types_tables = unanchored_type_coloring.build_tables(mtype2unanchored)
                else if modelbuilder.toolcontext.opt_phmod_typing.value then
                        var unanchored_type_coloring = new UnanchoredTypeModPerfectHashing
                        self.unanchored_types_colors = unanchored_type_coloring.colorize(mtype2unanchored)
                        self.unanchored_types_masks = unanchored_type_coloring.compute_masks(mtype2unanchored)
                        self.unanchored_types_tables = unanchored_type_coloring.build_tables(mtype2unanchored)
                else if modelbuilder.toolcontext.opt_phand_typing.value then
                        var unanchored_type_coloring = new UnanchoredTypeAndPerfectHashing
                        self.unanchored_types_colors = unanchored_type_coloring.colorize(mtype2unanchored)
                        self.unanchored_types_masks = unanchored_type_coloring.compute_masks(mtype2unanchored)
                        self.unanchored_types_tables = unanchored_type_coloring.build_tables(mtype2unanchored)
                else
                        var unanchored_type_coloring = new UnanchoredTypeColoring
                        self.unanchored_types_colors = unanchored_type_coloring.colorize(mtype2unanchored)
                        self.unanchored_types_tables = unanchored_type_coloring.build_tables(mtype2unanchored)
                end

                # Compile a C constant for each collected unanchored type.
                # Either to a color, or to -1 if the unanchored type is dead (no live receiver can require it)
                var all_unanchored = new HashSet[MType]
                for t in self.live_unanchored_types.values do
                        all_unanchored.add_all(t)
                end
                var all_unanchored_types_colors = new HashMap[MType, Int]
                for t in all_unanchored do
                        if unanchored_types_colors.has_key(t) then
                                all_unanchored_types_colors[t] = unanchored_types_colors[t]
                        else
                                all_unanchored_types_colors[t] = -1
                        end
                end
                self.compile_color_consts(all_unanchored_types_colors)

                #print "tables"
                #for k, v in unanchored_types_tables.as(not null) do
                #       print "{k}: {v.join(", ")}"
                #end
                #print ""
        end

        fun retieve_live_partial_types(mtype: MType) do
                # add formal types arguments to mtypes
                if mtype isa MGenericType then
                        for ft in mtype.arguments do
                                if ft.need_anchor then
                                        print("Why do we need anchor here ?")
                                        abort
                                end
                                self.partial_types.add(ft)
                                retieve_live_partial_types(ft)
                        end
                end
                var mclass_type: MClassType
                if mtype isa MNullableType then
                        mclass_type = mtype.mtype.as(MClassType)
                else
                        mclass_type = mtype.as(MClassType)
                end

                # add virtual types to mtypes
                for vt in self.vt_tables[mclass_type.mclass] do
                        if vt != null then
                                var anchored = vt.bound.anchor_to(self.mainmodule, mclass_type)
                                self.partial_types.add(anchored)
                        end
                end
        end

        # declare live generic types tables selection
        private fun compile_live_gentype_to_c(mclass: MClass) do
                if mclass.arity > 0 then
                        if self.livetypes_tables.has_key(mclass) then
                                var table = self.livetypes_tables[mclass]
                                var sign = self.livetypes_tables_sizes[mclass]
                                var table_buffer = new Buffer.from("const struct type *livetypes_{mclass.c_name}[{sign.join("][")}] = \{\n")
                                compile_livetype_table(table, table_buffer, 1, mclass.arity)
                                table_buffer.append("\};")

                                var v = new SeparateCompilerVisitor(self)
                                self.header.add_decl("extern const struct type *livetypes_{mclass.c_name}[{sign.join("][")}];")
                                v.add_decl(table_buffer.to_s)
                        else
                                var sign = new Array[Int].filled_with(0, mclass.arity)
                                var v = new SeparateCompilerVisitor(self)
                                self.header.add_decl("extern const struct type *livetypes_{mclass.c_name}[{sign.join("][")}];")
                                v.add_decl("const struct type *livetypes_{mclass.c_name}[{sign.join("][")}];")
                        end
                end
        end

        private fun compile_livetype_table(table: Array[nullable Object], buffer: Buffer, depth: Int, max: Int) do
                for obj in table do
                        if obj == null then
                                if depth == max then
                                        buffer.append("NULL,\n")
                                else
                                        buffer.append("\{\},\n")
                                end
                        else if obj isa MClassType then
                                buffer.append("(struct type*) &type_{obj.c_name}, /* {obj} */\n")
                        else if obj isa Array[nullable Object] then
                                buffer.append("\{\n")
                                compile_livetype_table(obj, buffer, depth + 1, max)
                                buffer.append("\},\n")
                        end
                end
        end

        # Separately compile all the method definitions of the module
        fun compile_module_to_c(mmodule: MModule)
        do
                var old_module = self.mainmodule
                self.mainmodule = mmodule
                for cd in mmodule.mclassdefs do
                        for pd in cd.mpropdefs do
                                if not pd isa MMethodDef then continue
                                #print "compile {pd} @ {cd} @ {mmodule}"
                                var r = new SeparateRuntimeFunction(pd)
                                r.compile_to_c(self)
                                if true or cd.bound_mtype.ctype != "val*" then
                                        var r2 = new VirtualRuntimeFunction(pd)
                                        r2.compile_to_c(self)
                                end
                        end
                end
                self.mainmodule = old_module
        end

        # Globaly compile the type structure of a live type
        fun compile_type_to_c(mtype: MType)
        do
                var c_name = mtype.c_name
                var v = new SeparateCompilerVisitor(self)
                v.add_decl("/* runtime type {mtype} */")

                # extern const struct type_X
                self.header.add_decl("extern const struct type_{c_name} type_{c_name};")
                self.header.add_decl("struct type_{c_name} \{")
                self.header.add_decl("int id;")
                self.header.add_decl("const char *name;")
                self.header.add_decl("int color;")
                self.header.add_decl("short int is_nullable;")
                if modelbuilder.toolcontext.opt_generic_tree.value then
                        self.header.add_decl("int livecolor;")
                        self.header.add_decl("const struct vts_table_{c_name} *vts_table;")
                        self.header.add_decl("const struct fts_table_{c_name} *fts_table;")
                else
                        self.header.add_decl("const struct types *unanchored_table;")
                end
                self.header.add_decl("int table_size;")
                self.header.add_decl("int type_table[{self.type_tables[mtype].length}];")
                self.header.add_decl("\};")

                # const struct type_X
                v.add_decl("const struct type_{c_name} type_{c_name} = \{")
                v.add_decl("{self.typeids[mtype]},")
                v.add_decl("\"{mtype}\", /* class_name_string */")
                v.add_decl("{self.type_colors[mtype]},")
                if mtype isa MNullableType then
                        v.add_decl("1,")
                else
                        v.add_decl("0,")
                end
                if modelbuilder.toolcontext.opt_generic_tree.value then
                        v.add_decl("{self.livetypes_colors[mtype]},")
                        if compile_type_vts_table(mtype) then
                                v.add_decl("&vts_table_{c_name},")
                        else
                                v.add_decl("NULL,")
                        end
                        if compile_type_fts_table(mtype) then
                                v.add_decl("&fts_table_{c_name},")
                        else
                                v.add_decl("NULL,")
                        end
                else
                        if compile_type_unanchored_table(mtype) then
                                v.add_decl("(struct types*) &unanchored_table_{c_name},")
                        else
                                v.add_decl("NULL,")
                        end
                end
                v.add_decl("{self.type_tables[mtype].length},")
                v.add_decl("\{")
                for stype in self.type_tables[mtype] do
                        if stype == null then
                                v.add_decl("-1, /* empty */")
                        else
                                v.add_decl("{self.typeids[stype]}, /* {stype} */")
                        end
                end
                v.add_decl("\},")
                v.add_decl("\};")
        end

        protected fun compile_type_fts_table(mtype: MType): Bool do

                var mclass_type: MClassType
                if mtype isa MNullableType then
                        mclass_type = mtype.mtype.as(MClassType)
                else
                        mclass_type = mtype.as(MClassType)
                end
                if self.ft_tables[mclass_type.mclass].is_empty then return false

                # extern const struct fst_table_X fst_table_X
                self.header.add_decl("extern const struct fts_table_{mtype.c_name} fts_table_{mtype.c_name};")
                self.header.add_decl("struct fts_table_{mtype.c_name} \{")
                if modelbuilder.toolcontext.opt_phmod_typing.value or modelbuilder.toolcontext.opt_phand_typing.value then
                        self.header.add_decl("int mask;")
                end
                self.header.add_decl("struct type *types[{self.ft_tables[mclass_type.mclass].length}];")
                self.header.add_decl("\};")

                # const struct fts_table_X fts_table_X
                var v = new_visitor
                v.add_decl("const struct fts_table_{mtype.c_name} fts_table_{mtype.c_name} = \{")
                if modelbuilder.toolcontext.opt_phmod_typing.value or modelbuilder.toolcontext.opt_phand_typing.value then
                        v.add_decl("{self.ft_masks[mclass_type.mclass]},")
                end
                v.add_decl("\{")
                for ft in self.ft_tables[mclass_type.mclass] do
                        if ft == null then
                                v.add_decl("NULL, /* empty */")
                        else
                                var ntype: MType
                                if ft.mclass == mclass_type.mclass then
                                        ntype = mclass_type.arguments[ft.rank]
                                else
                                        ntype = ft.anchor_to(self.mainmodule, mclass_type)
                                end
                                if self.typeids.has_key(ntype) then
                                        v.add_decl("(struct type*)&type_{ntype.c_name}, /* {ft} ({ntype}) */")
                                else
                                        v.add_decl("NULL, /* empty ({ft} not a live type) */")
                                end
                        end
                end
                v.add_decl("\},")
                v.add_decl("\};")
                return true
        end

        protected fun compile_type_vts_table(mtype: MType): Bool do

                var mclass_type: MClassType
                if mtype isa MNullableType then
                        mclass_type = mtype.mtype.as(MClassType)
                else
                        mclass_type = mtype.as(MClassType)
                end
                if self.vt_tables[mclass_type.mclass].is_empty then return false

                # extern const struct vts_table_X vts_table_X
                self.header.add_decl("extern const struct vts_table_{mtype.c_name} vts_table_{mtype.c_name};")
                self.header.add_decl("struct vts_table_{mtype.c_name} \{")
                if modelbuilder.toolcontext.opt_phmod_typing.value or modelbuilder.toolcontext.opt_phand_typing.value then
                        self.header.add_decl("int mask;")
                end
                self.header.add_decl("struct type *types[{self.vt_tables[mclass_type.mclass].length}];")
                self.header.add_decl("\};")

                # const struct vts_table_X vts_table_X
                var v = new_visitor
                v.add_decl("const struct vts_table_{mtype.c_name} vts_table_{mtype.c_name} = \{")
                if modelbuilder.toolcontext.opt_phmod_typing.value or modelbuilder.toolcontext.opt_phand_typing.value then
                        v.add_decl("{vt_masks[mclass_type.mclass]},")
                end
                v.add_decl("\{")

                for vt in self.vt_tables[mclass_type.mclass] do
                        if vt == null then
                                v.add_decl("NULL, /* empty */")
                        else
                                var bound = vt.bound
                                if bound == null then
                                        #FIXME how can a bound be null here ?
                                        print "No bound found for virtual type {vt} ?"
                                        abort
                                else
                                        var is_nullable = ""
                                        if bound isa MNullableType then
                                                bound = bound.mtype
                                                is_nullable = "nullable_"
                                        end
                                        if bound isa MVirtualType then
                                                bound = bound.anchor_to(self.mainmodule, mclass_type)
                                        else if bound isa MParameterType then
                                                bound = bound.anchor_to(self.mainmodule, mclass_type)
                                        else if bound isa MGenericType and bound.need_anchor then
                                                bound = bound.anchor_to(self.mainmodule, mclass_type)
                                        else if bound isa MClassType then
                                        else
                                                print "NOT YET IMPLEMENTED: mtype_to_livetype with type: {bound}"
                                                abort
                                        end

                                        if self.typeids.has_key(bound) then
                                                v.add_decl("(struct type*)&type_{is_nullable}{bound.c_name}, /* {bound} */")
                                        else
                                                v.add_decl("NULL, /* dead type {bound} */")
                                        end
                                end
                        end
                end
                v.add_decl("\},")
                v.add_decl("\};")
                return true
        end

        fun compile_type_unanchored_table(mtype: MType): Bool do

                var mclass_type: MClassType
                if mtype isa MNullableType then
                        mclass_type = mtype.mtype.as(MClassType)
                else
                        mclass_type = mtype.as(MClassType)
                end
                if not self.unanchored_types_tables.has_key(mclass_type) then return false

                # extern const struct unanchored_table_X unanchored_table_X
                self.header.add_decl("extern const struct unanchored_table_{mtype.c_name} unanchored_table_{mtype.c_name};")

                self.header.add_decl("struct unanchored_table_{mtype.c_name} \{")
                if modelbuilder.toolcontext.opt_phmod_typing.value or modelbuilder.toolcontext.opt_phand_typing.value then
                        self.header.add_decl("int mask;")
                end
                self.header.add_decl("struct type *types[{self.unanchored_types_tables[mclass_type].length}];")
                self.header.add_decl("\};")

                # const struct fts_table_X fts_table_X
                var v = new_visitor
                v.add_decl("const struct unanchored_table_{mtype.c_name} unanchored_table_{mtype.c_name} = \{")
                if modelbuilder.toolcontext.opt_phmod_typing.value or modelbuilder.toolcontext.opt_phand_typing.value then
                        v.add_decl("{self.unanchored_types_masks[mclass_type]},")
                end
                v.add_decl("\{")
                for t in self.unanchored_types_tables[mclass_type] do
                        if t == null then
                                v.add_decl("NULL, /* empty */")
                        else
                                # The table stores the result of the type resolution
                                # Therefore, for a receiver `mclass_type`, and a unresolved type `t`
                                # the value stored is tv.
                                var tv = t.resolve_for(mclass_type, mclass_type, self.mainmodule, true)
                                # FIXME: What typeids means here? How can a tv not be live?
                                if self.typeids.has_key(tv) then
                                        v.add_decl("(struct type*)&type_{tv.c_name}, /* {t}: {tv} */")
                                else
                                        v.add_decl("NULL, /* empty ({t}: {tv} not a live type) */")
                                end
                        end
                end
                v.add_decl("\},")
                v.add_decl("\};")
                return true
        end

        # Globally compile the table of the class mclass
        # In a link-time optimisation compiler, tables are globally computed
        # In a true separate compiler (a with dynamic loading) you cannot do this unfortnally
        fun compile_class_to_c(mclass: MClass)
        do
                var mtype = mclass.intro.bound_mtype
                var c_name = mclass.c_name

                var vft = self.method_tables[mclass]
                var attrs = self.attr_tables[mclass]
                var v = new_visitor

                v.add_decl("/* runtime class {c_name} */")
                var idnum = classids.length
                var idname = "ID_" + c_name
                self.classids[mtype] = idname
                #self.header.add_decl("#define {idname} {idnum} /* {c_name} */")

                self.header.add_decl("struct class_{c_name} \{")
                self.header.add_decl("int box_kind;")
                self.header.add_decl("nitmethod_t vft[{vft.length}];")
                self.header.add_decl("\};")

                # Build class vft
                self.header.add_decl("extern const struct class_{c_name} class_{c_name};")
                v.add_decl("const struct class_{c_name} class_{c_name} = \{")
                v.add_decl("{self.box_kind_of(mclass)}, /* box_kind */")
                v.add_decl("\{")
                for i in [0 .. vft.length[ do
                        var mpropdef = vft[i]
                        if mpropdef == null then
                                v.add_decl("NULL, /* empty */")
                        else
                                if true or mpropdef.mclassdef.bound_mtype.ctype != "val*" then
                                        v.add_decl("(nitmethod_t)VIRTUAL_{mpropdef.c_name}, /* pointer to {mclass.intro_mmodule}:{mclass}:{mpropdef} */")
                                else
                                        v.add_decl("(nitmethod_t){mpropdef.c_name}, /* pointer to {mclass.intro_mmodule}:{mclass}:{mpropdef} */")
                                end
                        end
                end
                v.add_decl("\}")
                v.add_decl("\};")

                if mtype.ctype != "val*" then
                        #Build instance struct
                        self.header.add_decl("struct instance_{c_name} \{")
                        self.header.add_decl("const struct type *type;")
                        self.header.add_decl("const struct class *class;")
                        self.header.add_decl("{mtype.ctype} value;")
                        self.header.add_decl("\};")

                        if not self.runtime_type_analysis.live_types.has(mtype) then return

                        self.header.add_decl("val* BOX_{c_name}({mtype.ctype});")
                        v.add_decl("/* allocate {mtype} */")
                        v.add_decl("val* BOX_{mtype.c_name}({mtype.ctype} value) \{")
                        v.add("struct instance_{c_name}*res = GC_MALLOC(sizeof(struct instance_{c_name}));")
                        v.add("res->type = (struct type*) &type_{c_name};")
                        v.add("res->class = (struct class*) &class_{c_name};")
                        v.add("res->value = value;")
                        v.add("return (val*)res;")
                        v.add("\}")
                        return
                end

                var is_native_array = mclass.name == "NativeArray"

                var sig
                if is_native_array then
                        sig = "int length, struct type* type"
                else
                        sig = "struct type* type"
                end

                #Build instance struct
                #extern const struct instance_array__NativeArray instance_array__NativeArray;
                self.header.add_decl("struct instance_{c_name} \{")
                self.header.add_decl("const struct type *type;")
                self.header.add_decl("const struct class *class;")
                self.header.add_decl("nitattribute_t attrs[{attrs.length}];")
                if is_native_array then
                        # NativeArrays are just a instance header followed by an array of values
                        self.header.add_decl("val* values[0];")
                end
                self.header.add_decl("\};")


                self.header.add_decl("{mtype.ctype} NEW_{c_name}({sig});")
                v.add_decl("/* allocate {mtype} */")
                v.add_decl("{mtype.ctype} NEW_{c_name}({sig}) \{")
                var res = v.new_named_var(mtype, "self")
                res.is_exact = true
                if is_native_array then
                        var mtype_elt = mtype.arguments.first
                        v.add("{res} = GC_MALLOC(sizeof(struct instance_{c_name}) + length*sizeof({mtype_elt.ctype}));")
                else
                        v.add("{res} = GC_MALLOC(sizeof(struct instance_{c_name}));")
                end
                v.add("{res}->type = type;")
                if v.compiler.modelbuilder.toolcontext.opt_hardening.value then
                        v.add("if(type == NULL) \{")
                        v.add_abort("type null")
                        v.add("\}")
                        v.add("if(type->unanchored_table == NULL) \{")
                        v.add("fprintf(stderr, \"Insantiation of a dead type: %s\\n\", type->name);")
                        v.add_abort("type dead")
                        v.add("\}")
                end
                v.add("{res}->class = (struct class*) &class_{c_name};")

                self.generate_init_attr(v, res, mtype)
                v.add("return {res};")
                v.add("\}")

                generate_check_init_instance(mtype)
        end

        redef fun generate_check_init_instance(mtype)
        do
                if self.modelbuilder.toolcontext.opt_no_check_initialization.value then return

                var v = self.new_visitor
                var c_name = mtype.mclass.c_name
                var res = new RuntimeVariable("self", mtype, mtype)
                self.header.add_decl("void CHECK_NEW_{c_name}({mtype.ctype});")
                v.add_decl("/* allocate {mtype} */")
                v.add_decl("void CHECK_NEW_{c_name}({mtype.ctype} {res}) \{")
                self.generate_check_attr(v, res, mtype)
                v.add("\}")
        end

        redef fun new_visitor do return new SeparateCompilerVisitor(self)
end

# The C function associated to a methoddef separately compiled
class SeparateRuntimeFunction
        super AbstractRuntimeFunction

        redef fun build_c_name: String
        do
                return "{mmethoddef.c_name}"
        end

        redef fun to_s do return self.mmethoddef.to_s

        redef fun compile_to_c(compiler)
        do
                var mmethoddef = self.mmethoddef

                var recv = self.mmethoddef.mclassdef.bound_mtype
                var v = compiler.new_visitor
                var selfvar = new RuntimeVariable("self", recv, recv)
                var arguments = new Array[RuntimeVariable]
                var frame = new Frame(v, mmethoddef, recv, arguments)
                v.frame = frame

                var msignature = mmethoddef.msignature.resolve_for(mmethoddef.mclassdef.bound_mtype, mmethoddef.mclassdef.bound_mtype, mmethoddef.mclassdef.mmodule, true)

                var sig = new Buffer
                var comment = new Buffer
                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
                sig.append(self.c_name)
                sig.append("({selfvar.mtype.ctype} {selfvar}")
                comment.append("(self: {selfvar}")
                arguments.add(selfvar)
                for i in [0..msignature.arity[ do
                        var mtype = msignature.mparameters[i].mtype
                        if i == msignature.vararg_rank then
                                mtype = v.get_class("Array").get_mtype([mtype])
                        end
                        comment.append(", {mtype}")
                        sig.append(", {mtype.ctype} p{i}")
                        var argvar = new RuntimeVariable("p{i}", mtype, mtype)
                        arguments.add(argvar)
                end
                sig.append(")")
                comment.append(")")
                if ret != null then
                        comment.append(": {ret}")
                end
                compiler.header.add_decl("{sig};")

                v.add_decl("/* method {self} for {comment} */")
                v.add_decl("{sig} \{")
                if ret != null then
                        frame.returnvar = v.new_var(ret)
                end
                frame.returnlabel = v.get_name("RET_LABEL")

                if recv != arguments.first.mtype then
                        #print "{self} {recv} {arguments.first}"
                end
                mmethoddef.compile_inside_to_c(v, arguments)

                v.add("{frame.returnlabel.as(not null)}:;")
                if ret != null then
                        v.add("return {frame.returnvar.as(not null)};")
                end
                v.add("\}")
        end
end

# The C function associated to a methoddef on a primitive type, stored into a VFT of a class
# The first parameter (the reciever) is always typed by val* in order to accept an object value
class VirtualRuntimeFunction
        super AbstractRuntimeFunction

        redef fun build_c_name: String
        do
                return "VIRTUAL_{mmethoddef.c_name}"
        end

        redef fun to_s do return self.mmethoddef.to_s

        redef fun compile_to_c(compiler)
        do
                var mmethoddef = self.mmethoddef

                var recv = self.mmethoddef.mclassdef.bound_mtype
                var v = compiler.new_visitor
                var selfvar = new RuntimeVariable("self", v.object_type, recv)
                var arguments = new Array[RuntimeVariable]
                var frame = new Frame(v, mmethoddef, recv, arguments)
                v.frame = frame

                var sig = new Buffer
                var comment = new Buffer

                # Because the function is virtual, the signature must match the one of the original class
                var intromclassdef = self.mmethoddef.mproperty.intro.mclassdef
                var msignature = mmethoddef.mproperty.intro.msignature.resolve_for(intromclassdef.bound_mtype, intromclassdef.bound_mtype, intromclassdef.mmodule, true)
                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
                sig.append(self.c_name)
                sig.append("({selfvar.mtype.ctype} {selfvar}")
                comment.append("(self: {selfvar}")
                arguments.add(selfvar)
                for i in [0..msignature.arity[ do
                        var mtype = msignature.mparameters[i].mtype
                        if i == msignature.vararg_rank then
                                mtype = v.get_class("Array").get_mtype([mtype])
                        end
                        comment.append(", {mtype}")
                        sig.append(", {mtype.ctype} p{i}")
                        var argvar = new RuntimeVariable("p{i}", mtype, mtype)
                        arguments.add(argvar)
                end
                sig.append(")")
                comment.append(")")
                if ret != null then
                        comment.append(": {ret}")
                end
                compiler.header.add_decl("{sig};")

                v.add_decl("/* method {self} for {comment} */")
                v.add_decl("{sig} \{")
                if ret != null then
                        frame.returnvar = v.new_var(ret)
                end
                frame.returnlabel = v.get_name("RET_LABEL")

                if recv != arguments.first.mtype then
                        #print "{self} {recv} {arguments.first}"
                end
                mmethoddef.compile_inside_to_c(v, arguments)

                v.add("{frame.returnlabel.as(not null)}:;")
                if ret != null then
                        v.add("return {frame.returnvar.as(not null)};")
                end
                v.add("\}")
        end

        redef fun call(v, arguments)
        do
                abort
                # TODO ?
        end
end

# A visitor on the AST of property definition that generate the C code of a separate compilation process.
class SeparateCompilerVisitor
        super GlobalCompilerVisitor # TODO better separation of concerns

        redef fun adapt_signature(m: MMethodDef, args: Array[RuntimeVariable])
        do
                var msignature = m.msignature.resolve_for(m.mclassdef.bound_mtype, m.mclassdef.bound_mtype, m.mclassdef.mmodule, true)
                var recv = args.first
                if recv.mtype.ctype != m.mclassdef.mclass.mclass_type.ctype then
                        args.first = self.autobox(args.first, m.mclassdef.mclass.mclass_type)
                end
                for i in [0..msignature.arity[ do
                        var t = msignature.mparameters[i].mtype
                        if i == msignature.vararg_rank then
                                t = args[i+1].mtype
                        end
                        args[i+1] = self.autobox(args[i+1], t)
                end
        end

        # Box or unbox a value to another type iff a C type conversion is needed
        # ENSURE: result.mtype.ctype == mtype.ctype
        redef fun autobox(value: RuntimeVariable, mtype: MType): RuntimeVariable
        do
                if value.mtype == mtype then
                        return value
                else if value.mtype.ctype == "val*" and mtype.ctype == "val*" then
                        return value
                else if value.mtype.ctype == "val*" then
                        return self.new_expr("((struct instance_{mtype.c_name}*){value})->value; /* autounbox from {value.mtype} to {mtype} */", mtype)
                else if mtype.ctype == "val*" then
                        var valtype = value.mtype.as(MClassType)
                        var res = self.new_var(mtype)
                        if not compiler.runtime_type_analysis.live_types.has(valtype) then
                                self.add("/*no autobox from {value.mtype} to {mtype}: {value.mtype} is not live! */")
                                self.add("printf(\"Dead code executed!\\n\"); exit(1);")
                                return res
                        end
                        self.add("{res} = BOX_{valtype.c_name}({value}); /* autobox from {value.mtype} to {mtype} */")
                        return res
                else
                        # Bad things will appen!
                        var res = self.new_var(mtype)
                        self.add("/* {res} left unintialized (cannot convert {value.mtype} to {mtype}) */")
                        self.add("printf(\"Cast error: Cannot cast %s to %s.\\n\", \"{value.mtype}\", \"{mtype}\"); exit(1);")
                        return res
                end
        end

        # Return a C expression returning the runtime type structure of the value
        # The point of the method is to works also with primitives types.
        fun type_info(value: RuntimeVariable): String
        do
                if value.mtype.ctype == "val*" then
                        return "{value}->type"
                else
                        return "(&type_{value.mtype.c_name})"
                end
        end

        redef fun send(mmethod, arguments)
        do
                if arguments.first.mcasttype.ctype != "val*" then
                        return self.monomorphic_send(mmethod, arguments.first.mcasttype, arguments)
                end

                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
                        res = null
                else
                        res = self.new_var(ret)
                end

                var s = new Buffer
                var ss = new Buffer

                var recv = arguments.first
                s.append("val*")
                ss.append("{recv}")
                self.varargize(mmethod.intro, mmethod.intro.msignature.as(not null), arguments)
                for i in [0..msignature.arity[ do
                        var a = arguments[i+1]
                        var t = msignature.mparameters[i].mtype
                        if i == msignature.vararg_rank then
                                t = arguments[i+1].mcasttype
                        end
                        s.append(", {t.ctype}")
                        a = self.autobox(a, t)
                        ss.append(", {a}")
                end

                var consider_null = not self.compiler.modelbuilder.toolcontext.opt_no_check_other.value or mmethod.name == "==" or mmethod.name == "!="
                var maybenull = recv.mcasttype isa MNullableType and consider_null
                if maybenull then
                        self.add("if ({recv} == NULL) \{")
                        if mmethod.name == "==" then
                                assert res != null
                                var arg = arguments[1]
                                if arg.mcasttype isa MNullableType then
                                        self.add("{res} = ({arg} == NULL);")
                                else if arg.mcasttype isa MNullType then
                                        self.add("{res} = 1; /* is null */")
                                else
                                        self.add("{res} = 0; /* {arg.inspect} cannot be null */")
                                end
                        else if mmethod.name == "!=" then
                                assert res != null
                                var arg = arguments[1]
                                if arg.mcasttype isa MNullableType then
                                        self.add("{res} = ({arg} != NULL);")
                                else if arg.mcasttype isa MNullType then
                                        self.add("{res} = 0; /* is null */")
                                else
                                        self.add("{res} = 1; /* {arg.inspect} cannot be null */")
                                end
                        else
                                self.add_abort("Reciever is null")
                        end
                        self.add("\} else \{")
                end

                var r
                if ret == null then r = "void" else r = ret.ctype
                var call = "(({r} (*)({s}))({arguments.first}->class->vft[{mmethod.const_color}]))({ss}) /* {mmethod} on {arguments.first.inspect}*/"

                if res != null then
                        self.add("{res} = {call};")
                else
                        self.add("{call};")
                end

                if maybenull then
                        self.add("\}")
                end

                return res
        end

        redef fun call(mmethoddef, recvtype, arguments)
        do
                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
                        res = null
                else
                        ret = ret.resolve_for(mmethoddef.mclassdef.bound_mtype, mmethoddef.mclassdef.bound_mtype, mmethoddef.mclassdef.mmodule, true)
                        res = self.new_var(ret)
                end

                if self.compiler.modelbuilder.mpropdef2npropdef.has_key(mmethoddef) and
                self.compiler.modelbuilder.mpropdef2npropdef[mmethoddef] isa AInternMethPropdef and
                not compiler.modelbuilder.toolcontext.opt_no_inline_intern.value then
                        var frame = new Frame(self, mmethoddef, recvtype, arguments)
                        frame.returnlabel = self.get_name("RET_LABEL")
                        frame.returnvar = res
                        var old_frame = self.frame
                        self.frame = frame
                        self.add("\{ /* Inline {mmethoddef} ({arguments.join(",")}) */")
                        mmethoddef.compile_inside_to_c(self, arguments)
                        self.add("{frame.returnlabel.as(not null)}:(void)0;")
                        self.add("\}")
                        self.frame = old_frame
                        return res
                end

                # Autobox arguments
                self.adapt_signature(mmethoddef, arguments)

                if res == null then
                        self.add("{mmethoddef.c_name}({arguments.join(", ")});")
                        return null
                else
                        self.add("{res} = {mmethoddef.c_name}({arguments.join(", ")});")
                end

                return res
        end

        redef fun vararg_instance(mpropdef, recv, varargs, elttype)
        do
                # A vararg must be stored into an new array
                # The trick is that the dymaic type of the array may depends on the receiver
                # of the method (ie recv) if the static type is unresolved
                # This is more complex than usual because the unanchored type must not be resolved
                # with the current receiver (ie self).
                # Therefore to isolate the resolution from self, a local Frame is created.
                # One can see this implementation as an inlined method of the receiver whose only
                # job is to allocate the array
                var old_frame = self.frame
                var frame = new Frame(self, mpropdef, mpropdef.mclassdef.bound_mtype, [recv])
                self.frame = frame
                #print "required Array[{elttype}] for recv {recv.inspect}. bound=Array[{self.resolve_for(elttype, recv)}]. selfvar={frame.arguments.first.inspect}"
                var res = self.array_instance(varargs, elttype)
                self.frame = old_frame
                return res
        end

        redef fun isset_attribute(a, recv)
        do
                self.check_recv_notnull(recv)
                var res = self.new_var(bool_type)
                self.add("{res} = {recv}->attrs[{a.const_color}] != NULL; /* {a} on {recv.inspect}*/")
                return res
        end

        redef fun read_attribute(a, recv)
        do
                self.check_recv_notnull(recv)

                # What is the declared type of the attribute?
                var ret = a.intro.static_mtype.as(not null)
                var intromclassdef = a.intro.mclassdef
                ret = ret.resolve_for(intromclassdef.bound_mtype, intromclassdef.bound_mtype, intromclassdef.mmodule, true)

                # Get the attribute or a box (ie. always a val*)
                var cret = self.object_type.as_nullable
                var res = self.new_var(cret)
                res.mcasttype = ret
                self.add("{res} = {recv}->attrs[{a.const_color}]; /* {a} on {recv.inspect} */")

                # Check for Uninitialized attribute
                if not ret isa MNullableType and not self.compiler.modelbuilder.toolcontext.opt_no_check_initialization.value then
                        self.add("if ({res} == NULL) \{")
                        self.add_abort("Uninitialized attribute {a.name}")
                        self.add("\}")
                end

                # Return the attribute or its unboxed version
                # Note: it is mandatory since we reuse the box on write, we do not whant that the box escapes
                return self.autobox(res, ret)
        end

        redef fun write_attribute(a, recv, value)
        do
                self.check_recv_notnull(recv)

                # What is the declared type of the attribute?
                var mtype = a.intro.static_mtype.as(not null)
                var intromclassdef = a.intro.mclassdef
                mtype = mtype.resolve_for(intromclassdef.bound_mtype, intromclassdef.bound_mtype, intromclassdef.mmodule, true)

                # Adapt the value to the declared type
                value = self.autobox(value, mtype)
                var attr = "{recv}->attrs[{a.const_color}]"
                if mtype.ctype != "val*" then
                        assert mtype isa MClassType
                        # The attribute is primitive, thus we store it in a box
                        # The trick is to create the box the first time then resuse the box
                        self.add("if ({attr} != NULL) \{")
                        self.add("((struct instance_{mtype.c_name}*){attr})->value = {value}; /* {a} on {recv.inspect} */")
                        self.add("\} else \{")
                        value = self.autobox(value, self.object_type.as_nullable)
                        self.add("{attr} = {value}; /* {a} on {recv.inspect} */")
                        self.add("\}")
                else
                        # The attribute is not primitive, thus store it direclty
                        self.add("{attr} = {value}; /* {a} on {recv.inspect} */")
                end
        end

        # Build livetype structure retrieving
        #ENSURE: mtype.need_anchor
        fun retrieve_anchored_livetype(mtype: MGenericType, buffer: Buffer) do
                assert mtype.need_anchor

                var compiler = self.compiler.as(SeparateCompiler)
                for ft in mtype.arguments do

                        var ntype = ft
                        var s: String = ""
                        if ntype isa MNullableType then
                                ntype = ntype.mtype
                        end

                        var recv = self.frame.arguments.first
                        var recv_type_info = self.type_info(recv)
                        if ntype isa MParameterType then
                                if compiler.modelbuilder.toolcontext.opt_phmod_typing.value or compiler.modelbuilder.toolcontext.opt_phand_typing.value then
                                        buffer.append("[{recv_type_info}->fts_table->types[HASH({recv_type_info}->fts_table->mask, {ntype.const_color})]->livecolor]")
                                else
                                        buffer.append("[{recv_type_info}->fts_table->types[{ntype.const_color}]->livecolor]")
                                end
                        else if ntype isa MVirtualType then
                                if compiler.modelbuilder.toolcontext.opt_phmod_typing.value or compiler.modelbuilder.toolcontext.opt_phand_typing.value then
                                        buffer.append("[{recv_type_info}->vts_table->types[HASH({recv_type_info}->vts_table->mask, {ntype.mproperty.const_color})]->livecolor]")
                                else
                                        buffer.append("[{recv_type_info}->vts_table->types[{ntype.mproperty.const_color}]->livecolor]")
                                end
                        else if ntype isa MGenericType and ntype.need_anchor then
                                var bbuff = new Buffer
                                retrieve_anchored_livetype(ntype, bbuff)
                                buffer.append("[livetypes_{ntype.mclass.c_name}{bbuff.to_s}->livecolor]")
                        else if ntype isa MClassType then
                                compiler.undead_types.add(ft)
                                buffer.append("[type_{ft.c_name}.livecolor]")
                        else
                                self.add("printf(\"NOT YET IMPLEMENTED: init_instance(%s, {mtype}).\\n\", \"{ft}\"); exit(1);")
                        end
                end
        end

        redef fun init_instance(mtype)
        do
                var compiler = self.compiler.as(SeparateCompiler)
                if mtype isa MGenericType and mtype.need_anchor then
                        if compiler.modelbuilder.toolcontext.opt_generic_tree.value then
                                var buff = new Buffer
                                retrieve_anchored_livetype(mtype, buff)
                                mtype = self.anchor(mtype).as(MClassType)
                                return self.new_expr("NEW_{mtype.mclass.c_name}((struct type *) livetypes_{mtype.mclass.c_name}{buff.to_s})", mtype)
                        else
                                link_unanchored_type(self.frame.mpropdef.mclassdef, mtype)
                                var recv = self.frame.arguments.first
                                var recv_type_info = self.type_info(recv)
                                if compiler.modelbuilder.toolcontext.opt_phmod_typing.value or compiler.modelbuilder.toolcontext.opt_phand_typing.value then
                                        return self.new_expr("NEW_{mtype.mclass.c_name}((struct type *) {recv_type_info}->unanchored_table->types[HASH({recv_type_info}->unanchored_table->mask, {mtype.const_color})])", mtype)
                                else
                                        return self.new_expr("NEW_{mtype.mclass.c_name}((struct type *) {recv_type_info}->unanchored_table->types[{mtype.const_color}])", mtype)
                                end
                        end
                end
                compiler.undead_types.add(mtype)
                return self.new_expr("NEW_{mtype.mclass.c_name}((struct type *) &type_{mtype.c_name})", mtype)
        end

        redef fun check_init_instance(value, mtype)
        do
                if self.compiler.modelbuilder.toolcontext.opt_no_check_initialization.value then return
                self.add("CHECK_NEW_{mtype.mclass.c_name}({value});")
        end


        redef fun type_test(value, mtype)
        do
                self.add("/* {value.inspect} isa {mtype} */")
                var compiler = self.compiler.as(SeparateCompiler)

                var recv = self.frame.arguments.first
                var recv_type_info = self.type_info(recv)

                var res = self.new_var(bool_type)

                var cltype = self.get_name("cltype")
                self.add_decl("int {cltype};")
                var idtype = self.get_name("idtype")
                self.add_decl("int {idtype};")
                var is_nullable = self.get_name("is_nullable")
                self.add_decl("short int {is_nullable};")

                var ntype = mtype
                if ntype isa MNullableType then
                        ntype = ntype.mtype
                end

                if ntype.need_anchor then
                        var type_struct = self.get_name("type_struct")
                        self.add_decl("struct type* {type_struct};")

                        # For unresolved types, there is two implementations
                        if compiler.modelbuilder.toolcontext.opt_generic_tree.value then
                                # Either with the generic_tree and the construction of a type
                                if ntype isa MParameterType then
                                        if compiler.modelbuilder.toolcontext.opt_phmod_typing.value or compiler.modelbuilder.toolcontext.opt_phand_typing.value then
                                                self.add("{type_struct} = {recv_type_info}->fts_table->types[HASH({recv_type_info}->fts_table->mask, {ntype.const_color})];")
                                        else
                                                self.add("{type_struct} = {recv_type_info}->fts_table->types[{ntype.const_color}];")
                                        end
                                else if ntype isa MVirtualType then
                                        var vtcolor = ntype.mproperty.const_color
                                        if compiler.modelbuilder.toolcontext.opt_phmod_typing.value or compiler.modelbuilder.toolcontext.opt_phand_typing.value then
                                                self.add("{type_struct} = {recv_type_info}->vts_table->types[HASH({recv_type_info}->vts_table->mask, {vtcolor})];")
                                        else
                                                self.add("{type_struct} = {recv_type_info}->vts_table->types[{vtcolor}];")
                                        end
                                else if ntype isa MGenericType then
                                        var buff = new Buffer
                                        retrieve_anchored_livetype(ntype, buff)
                                        self.add("{type_struct} = (struct type*)livetypes_{ntype.mclass.c_name}{buff.to_s};")
                                end
                        else
                                # Either with unanchored_table with a direct resolution
                                link_unanchored_type(self.frame.mpropdef.mclassdef, ntype)
                                if compiler.modelbuilder.toolcontext.opt_phmod_typing.value or compiler.modelbuilder.toolcontext.opt_phand_typing.value then
                                        self.add("{type_struct} = {recv_type_info}->unanchored_table->types[HASH({recv_type_info}->unanchored_table->mask, {ntype.const_color})];")
                                else
                                        self.add("{type_struct} = {recv_type_info}->unanchored_table->types[{ntype.const_color}];")
                                end
                        end
                        self.add("{cltype} = {type_struct}->color;")
                        self.add("{idtype} = {type_struct}->id;")
                        self.add("{is_nullable} = {type_struct}->is_nullable;")
                else if ntype isa MClassType then
                        compiler.undead_types.add(mtype)
                        self.add("{cltype} = type_{mtype.c_name}.color;")
                        self.add("{idtype} = type_{mtype.c_name}.id;")
                        self.add("{is_nullable} = type_{mtype.c_name}.is_nullable;")
                else
                        self.add("printf(\"NOT YET IMPLEMENTED: type_test(%s, {mtype}).\\n\", \"{value.inspect}\"); exit(1);")
                end

                if mtype isa MNullableType then
                        self.add("{is_nullable} = 1;")
                end

                # check color is in table
                if self.maybe_null(value) then
                        self.add("if({value} == NULL) \{")
                        self.add("{res} = {is_nullable};")
                        self.add("\} else \{")
                end
                var value_type_info = self.type_info(value)
                if compiler.modelbuilder.toolcontext.opt_phmod_typing.value or compiler.modelbuilder.toolcontext.opt_phand_typing.value then
                        self.add("{cltype} = HASH({value_type_info}->color, {idtype});")
                end
                self.add("if({cltype} >= {value_type_info}->table_size) \{")
                self.add("{res} = 0;")
                self.add("\} else \{")
                self.add("{res} = {value_type_info}->type_table[{cltype}] == {idtype};")
                self.add("\}")
                if self.maybe_null(value) then
                        self.add("\}")
                end

                return res
        end

        redef fun is_same_type_test(value1, value2)
        do
                var res = self.new_var(bool_type)
                # Swap values to be symetric
                if value2.mtype.ctype != "val*" and value1.mtype.ctype == "val*" then
                        var tmp = value1
                        value1 = value2
                        value2 = tmp
                end
                if value1.mtype.ctype != "val*" then
                        if value2.mtype == value1.mtype then
                                self.add("{res} = 1; /* is_same_type_test: compatible types {value1.mtype} vs. {value2.mtype} */")
                        else if value2.mtype.ctype != "val*" then
                                self.add("{res} = 0; /* is_same_type_test: incompatible types {value1.mtype} vs. {value2.mtype}*/")
                        else
                                var mtype1 = value1.mtype.as(MClassType)
                                self.add("{res} = ({value2} != NULL) && ({value2}->class == (struct class*) &class_{mtype1.c_name}); /* is_same_type_test */")
                        end
                else
                        self.add("{res} = ({value1} == {value2}) || ({value1} != NULL && {value2} != NULL && {value1}->class == {value2}->class); /* is_same_type_test */")
                end
                return res
        end

        redef fun class_name_string(value)
        do
                var res = self.get_name("var_class_name")
                self.add_decl("const char* {res};")
                if value.mtype.ctype == "val*" then
                        self.add "{res} = {value} == NULL ? \"null\" : {value}->type->name;"
                else
                        self.add "{res} = type_{value.mtype.c_name}.name;"
                end
                return res
        end

        redef fun equal_test(value1, value2)
        do
                var res = self.new_var(bool_type)
                if value2.mtype.ctype != "val*" and value1.mtype.ctype == "val*" then
                        var tmp = value1
                        value1 = value2
                        value2 = tmp
                end
                if value1.mtype.ctype != "val*" then
                        if value2.mtype == value1.mtype then
                                self.add("{res} = {value1} == {value2};")
                        else if value2.mtype.ctype != "val*" then
                                self.add("{res} = 0; /* incompatible types {value1.mtype} vs. {value2.mtype}*/")
                        else
                                var mtype1 = value1.mtype.as(MClassType)
                                self.add("{res} = ({value2} != NULL) && ({value2}->class == (struct class*) &class_{mtype1.c_name});")
                                self.add("if ({res}) \{")
                                self.add("{res} = ({self.autobox(value2, value1.mtype)} == {value1});")
                                self.add("\}")
                        end
                        return res
                end
                var maybe_null = true
                var test = new Array[String]
                var t1 = value1.mcasttype
                if t1 isa MNullableType then
                        test.add("{value1} != NULL")
                        t1 = t1.mtype
                else
                        maybe_null = false
                end
                var t2 = value2.mcasttype
                if t2 isa MNullableType then
                        test.add("{value2} != NULL")
                        t2 = t2.mtype
                else
                        maybe_null = false
                end

                var incompatible = false
                var primitive
                if t1.ctype != "val*" then
                        primitive = t1
                        if t1 == t2 then
                                # No need to compare class
                        else if t2.ctype != "val*" then
                                incompatible = true
                        else if can_be_primitive(value2) then
                                test.add("{value1}->class == {value2}->class")
                        else
                                incompatible = true
                        end
                else if t2.ctype != "val*" then
                        primitive = t2
                        if can_be_primitive(value1) then
                                test.add("{value1}->class == {value2}->class")
                        else
                                incompatible = true
                        end
                else
                        primitive = null
                end

                if incompatible then
                        if maybe_null then
                                self.add("{res} = {value1} == {value2}; /* incompatible types {t1} vs. {t2}; but may be NULL*/")
                                return res
                        else
                                self.add("{res} = 0; /* incompatible types {t1} vs. {t2}; cannot be NULL */")
                                return res
                        end
                end
                if primitive != null then
                        test.add("((struct instance_{primitive.c_name}*){value1})->value == ((struct instance_{primitive.c_name}*){value2})->value")
                else if can_be_primitive(value1) and can_be_primitive(value2) then
                        test.add("{value1}->class == {value2}->class")
                        var s = new Array[String]
                        for t, v in self.compiler.as(SeparateCompiler).box_kinds do
                                s.add "({value1}->class->box_kind == {v} && ((struct instance_{t.c_name}*){value1})->value == ((struct instance_{t.c_name}*){value2})->value)"
                        end
                        test.add("({s.join(" || ")})")
                else
                        self.add("{res} = {value1} == {value2};")
                        return res
                end
                self.add("{res} = {value1} == {value2} || ({test.join(" && ")});")
                return res
        end

        fun can_be_primitive(value: RuntimeVariable): Bool
        do
                var t = value.mcasttype
                if t isa MNullableType then t = t.mtype
                if not t isa MClassType then return false
                var k = t.mclass.kind
                return k == interface_kind or t.ctype != "val*"
        end

        fun maybe_null(value: RuntimeVariable): Bool
        do
                var t = value.mcasttype
                return t isa MNullableType or t isa MNullType
        end

        redef fun array_instance(array, elttype)
        do
                var nclass = self.get_class("NativeArray")
                var arrayclass = self.get_class("Array")
                var arraytype = arrayclass.get_mtype([elttype])
                var res = self.init_instance(arraytype)
                self.add("\{ /* {res} = array_instance Array[{elttype}] */")
                var length = self.int_instance(array.length)
                var nat = native_array_instance(elttype, length)
                for i in [0..array.length[ do
                        var r = self.autobox(array[i], self.object_type)
                        self.add("((struct instance_{nclass.c_name}*){nat})->values[{i}] = (val*) {r};")
                end
                self.send(self.get_property("with_native", arrayclass.intro.bound_mtype), [res, nat, length])
                self.check_init_instance(res, arraytype)
                self.add("\}")
                return res
        end

        fun native_array_instance(elttype: MType, length: RuntimeVariable): RuntimeVariable
        do
                var mtype = self.get_class("NativeArray").get_mtype([elttype])
                assert mtype isa MGenericType
                var compiler = self.compiler.as(SeparateCompiler)
                if mtype.need_anchor then
                        if compiler.modelbuilder.toolcontext.opt_generic_tree.value then
                                var buff = new Buffer
                                retrieve_anchored_livetype(mtype, buff)
                                mtype = self.anchor(mtype).as(MClassType)
                                return self.new_expr("NEW_{mtype.mclass.c_name}({length}, (struct type *) livetypes_{mtype.mclass.c_name}{buff.to_s})", mtype)
                        else
                                link_unanchored_type(self.frame.mpropdef.mclassdef, mtype)
                                var recv = self.frame.arguments.first
                                var recv_type_info = self.type_info(recv)
                                if compiler.modelbuilder.toolcontext.opt_phmod_typing.value or compiler.modelbuilder.toolcontext.opt_phand_typing.value then
                                        return self.new_expr("NEW_{mtype.mclass.c_name}({length}, (struct type *) {recv_type_info}->unanchored_table->types[HASH({recv_type_info}->unanchored_table->mask, {mtype.const_color})])", mtype)
                                else
                                        return self.new_expr("NEW_{mtype.mclass.c_name}({length}, (struct type *) {recv_type_info}->unanchored_table->types[{mtype.const_color}])", mtype)
                                end
                        end
                end
                compiler.undead_types.add(mtype)
                return self.new_expr("NEW_{mtype.mclass.c_name}({length}, (struct type *) &type_{mtype.c_name})", mtype)
        end

        redef fun native_array_def(pname, ret_type, arguments)
        do
                var elttype = arguments.first.mtype
                var nclass = self.get_class("NativeArray")
                var recv = "((struct instance_{nclass.c_name}*){arguments[0]})->values"
                if pname == "[]" then
                        self.ret(self.new_expr("{recv}[{arguments[1]}]", ret_type.as(not null)))
                        return
                else if pname == "[]=" then
                        self.add("{recv}[{arguments[1]}]={arguments[2]};")
                        return
                else if pname == "copy_to" then
                        var recv1 = "((struct instance_{nclass.c_name}*){arguments[1]})->values"
                        self.add("memcpy({recv1}, {recv}, {arguments[2]}*sizeof({elttype.ctype}));")
                        return
                end
        end

        redef fun calloc_array(ret_type, arguments)
        do
                var mclass = self.get_class("ArrayCapable")
                var ft = mclass.mclass_type.arguments.first.as(MParameterType)
                var res = self.native_array_instance(ft, arguments[1])
                self.ret(res)
        end

        fun link_unanchored_type(mclassdef: MClassDef, mtype: MType) do
                assert mtype.need_anchor
                var compiler = self.compiler.as(SeparateCompiler)
                if not compiler.live_unanchored_types.has_key(self.frame.mpropdef.mclassdef) then
                        compiler.live_unanchored_types[self.frame.mpropdef.mclassdef] = new HashSet[MType]
                end
                compiler.live_unanchored_types[self.frame.mpropdef.mclassdef].add(mtype)
        end
end

redef class MClass
        # Return the name of the C structure associated to a Nit class
        fun c_name: String do
                var res = self.c_name_cache
                if res != null then return res
                res = "{intro_mmodule.name.to_cmangle}__{name.to_cmangle}"
                self.c_name_cache = res
                return res
        end
        private var c_name_cache: nullable String
end

redef class MType
        fun const_color: String do return "COLOR_{c_name}"
end

redef class MParameterType
        redef fun c_name
        do
                var res = self.c_name_cache
                if res != null then return res
                res = "{self.mclass.c_name}_FT{self.rank}"
                self.c_name_cache = res
                return res
        end
end

redef class MVirtualType
        redef fun c_name
        do
                var res = self.c_name_cache
                if res != null then return res
                res = "{self.mproperty.intro.mclassdef.mclass.c_name}_VT{self.mproperty.name}"
                self.c_name_cache = res
                return res
        end
end

redef class MNullableType
        redef fun c_name
        do
                var res = self.c_name_cache
                if res != null then return res
                res = "nullable_{self.mtype.c_name}"
                self.c_name_cache = res
                return res
        end
end

redef class MProperty
        fun c_name: String do
                var res = self.c_name_cache
                if res != null then return res
                res = "{self.intro.c_name}"
                self.c_name_cache = res
                return res
        end
        private var c_name_cache: nullable String

        fun const_color: String do return "COLOR_{c_name}"
end