compiler: skip compilation of broken methods

[nit.git] / src / compiler / separate_compiler.nit

diff --git a/src/compiler/separate_compiler.nit b/src/compiler/separate_compiler.nit
index 555c220..dc24b7c 100644 (file)
--- a/src/compiler/separate_compiler.nit
+++ b/src/compiler/separate_compiler.nit
@@ -269,7 +269,7 @@ class SeparateCompiler
                if mclass.mclass_type.ctype_extern == "val*" then
                        return 0
                else if mclass.kind == extern_kind and mclass.name != "NativeString" then
                if mclass.mclass_type.ctype_extern == "val*" then
                        return 0
                else if mclass.kind == extern_kind and mclass.name != "NativeString" then

-                       return self.box_kinds[self.mainmodule.get_primitive_class("Pointer")]
+                       return self.box_kinds[self.mainmodule.pointer_type.mclass]

                else
                        return self.box_kinds[mclass]
                end
                else
                        return self.box_kinds[mclass]
                end

@@ -458,14 +458,14 @@ class SeparateCompiler
 
                var mtypes_by_class = new MultiHashMap[MClass, MType]
                for e in mtypes do
 
                var mtypes_by_class = new MultiHashMap[MClass, MType]
                for e in mtypes do

-                       var c = e.as_notnullable.as(MClassType).mclass
+                       var c = e.undecorate.as(MClassType).mclass

                        mtypes_by_class[c].add(e)
                        poset.add_node(e)
                end
 
                var casttypes_by_class = new MultiHashMap[MClass, MType]
                for e in cast_types do
                        mtypes_by_class[c].add(e)
                        poset.add_node(e)
                end
 
                var casttypes_by_class = new MultiHashMap[MClass, MType]
                for e in cast_types do

-                       var c = e.as_notnullable.as(MClassType).mclass
+                       var c = e.undecorate.as(MClassType).mclass

                        casttypes_by_class[c].add(e)
                        poset.add_node(e)
                end
                        casttypes_by_class[c].add(e)
                        poset.add_node(e)
                end

@@ -510,7 +510,7 @@ class SeparateCompiler
                # Group cast_type by their classes
                var bucklets = new HashMap[MClass, Set[MType]]
                for e in cast_types do
                # Group cast_type by their classes
                var bucklets = new HashMap[MClass, Set[MType]]
                for e in cast_types do

-                       var c = e.as_notnullable.as(MClassType).mclass
+                       var c = e.undecorate.as(MClassType).mclass

                        if not bucklets.has_key(c) then
                                bucklets[c] = new HashSet[MType]
                        end
                        if not bucklets.has_key(c) then
                                bucklets[c] = new HashSet[MType]
                        end

@@ -625,6 +625,7 @@ class SeparateCompiler
                for cd in mmodule.mclassdefs do
                        for pd in cd.mpropdefs do
                                if not pd isa MMethodDef then continue
                for cd in mmodule.mclassdefs do
                        for pd in cd.mpropdefs do
                                if not pd isa MMethodDef then continue

+                               if pd.msignature == null then continue # Skip broken method

                                var rta = runtime_type_analysis
                                if modelbuilder.toolcontext.opt_skip_dead_methods.value and rta != null and not rta.live_methoddefs.has(pd) then continue
                                #print "compile {pd} @ {cd} @ {mmodule}"
                                var rta = runtime_type_analysis
                                if modelbuilder.toolcontext.opt_skip_dead_methods.value and rta != null and not rta.live_methoddefs.has(pd) then continue
                                #print "compile {pd} @ {cd} @ {mmodule}"

@@ -742,7 +743,7 @@ class SeparateCompiler
 
                # resolution table (for receiver)
                if is_live then
 
                # resolution table (for receiver)
                if is_live then

-                       var mclass_type = mtype.as_notnullable
+                       var mclass_type = mtype.undecorate

                        assert mclass_type isa MClassType
                        if resolution_tables[mclass_type].is_empty then
                                v.add_decl("NULL, /*NO RESOLUTIONS*/")
                        assert mclass_type isa MClassType
                        if resolution_tables[mclass_type].is_empty then
                                v.add_decl("NULL, /*NO RESOLUTIONS*/")

@@ -775,7 +776,7 @@ class SeparateCompiler
 
        fun compile_type_resolution_table(mtype: MType) do
 
 
        fun compile_type_resolution_table(mtype: MType) do
 

-               var mclass_type = mtype.as_notnullable.as(MClassType)
+               var mclass_type = mtype.undecorate.as(MClassType)

 
                # extern const struct resolution_table_X resolution_table_X
                self.provide_declaration("resolution_table_{mtype.c_name}", "extern const struct types resolution_table_{mtype.c_name};")
 
                # extern const struct resolution_table_X resolution_table_X
                self.provide_declaration("resolution_table_{mtype.c_name}", "extern const struct types resolution_table_{mtype.c_name};")

@@ -817,7 +818,7 @@ class SeparateCompiler
                var v = new_visitor
 
                var rta = runtime_type_analysis
                var v = new_visitor
 
                var rta = runtime_type_analysis

-               var is_dead = rta != null and not rta.live_classes.has(mclass) and mtype.ctype == "val*" and mclass.name != "NativeArray" and mclass.name != "Pointer"
+               var is_dead = rta != null and not rta.live_classes.has(mclass) and not mtype.is_c_primitive and mclass.name != "NativeArray" and mclass.name != "Pointer"

 
                v.add_decl("/* runtime class {c_name} */")
 
 
                v.add_decl("/* runtime class {c_name} */")
 

@@ -847,7 +848,7 @@ class SeparateCompiler
                        v.add_decl("\};")
                end
 
                        v.add_decl("\};")
                end
 

-               if mtype.ctype != "val*" or mtype.mclass.name == "Pointer" then
+               if mtype.is_c_primitive or mtype.mclass.name == "Pointer" then

                        # Is a primitive type or the Pointer class, not any other extern class
 
                        if mtype.is_tagged then return
                        # Is a primitive type or the Pointer class, not any other extern class
 
                        if mtype.is_tagged then return

@@ -1185,9 +1186,9 @@ class SeparateCompilerVisitor
        do
                if value.mtype == mtype then
                        return value
        do
                if value.mtype == mtype then
                        return value

-               else if value.mtype.ctype == "val*" and mtype.ctype == "val*" then
+               else if not value.mtype.is_c_primitive and not mtype.is_c_primitive then

                        return value
                        return value

-               else if value.mtype.ctype == "val*" then
+               else if not value.mtype.is_c_primitive then

                        if mtype.is_tagged then
                                if mtype.name == "Int" then
                                        return self.new_expr("(long)({value})>>2", mtype)
                        if mtype.is_tagged then
                                if mtype.name == "Int" then
                                        return self.new_expr("(long)({value})>>2", mtype)

@@ -1200,7 +1201,7 @@ class SeparateCompilerVisitor
                                end
                        end
                        return self.new_expr("((struct instance_{mtype.c_name}*){value})->value; /* autounbox from {value.mtype} to {mtype} */", mtype)
                                end
                        end
                        return self.new_expr("((struct instance_{mtype.c_name}*){value})->value; /* autounbox from {value.mtype} to {mtype} */", mtype)

-               else if mtype.ctype == "val*" then
+               else if not mtype.is_c_primitive then

                        if value.mtype.is_tagged then
                                if value.mtype.name == "Int" then
                                        return self.new_expr("(val*)({value}<<2|1)", mtype)
                        if value.mtype.is_tagged then
                                if value.mtype.name == "Int" then
                                        return self.new_expr("(val*)({value}<<2|1)", mtype)

@@ -1280,7 +1281,7 @@ class SeparateCompilerVisitor
        # Thus the expression can be used as a condition.
        fun extract_tag(value: RuntimeVariable): String
        do
        # Thus the expression can be used as a condition.
        fun extract_tag(value: RuntimeVariable): String
        do

-               assert value.mtype.ctype == "val*"
+               assert not value.mtype.is_c_primitive

                return "((long){value}&3)" # Get the two low bits
        end
 
                return "((long){value}&3)" # Get the two low bits
        end
 

@@ -1288,7 +1289,7 @@ class SeparateCompilerVisitor
        # The point of the method is to work also with primitive types.
        fun class_info(value: RuntimeVariable): String
        do
        # The point of the method is to work also with primitive types.
        fun class_info(value: RuntimeVariable): String
        do

-               if value.mtype.ctype == "val*" then
+               if not value.mtype.is_c_primitive then

                        if can_be_primitive(value) and not compiler.modelbuilder.toolcontext.opt_no_tag_primitives.value then
                                var tag = extract_tag(value)
                                return "({tag}?class_info[{tag}]:{value}->class)"
                        if can_be_primitive(value) and not compiler.modelbuilder.toolcontext.opt_no_tag_primitives.value then
                                var tag = extract_tag(value)
                                return "({tag}?class_info[{tag}]:{value}->class)"

@@ -1305,7 +1306,7 @@ class SeparateCompilerVisitor
        # The point of the method is to work also with primitive types.
        fun type_info(value: RuntimeVariable): String
        do
        # The point of the method is to work also with primitive types.
        fun type_info(value: RuntimeVariable): String
        do

-               if value.mtype.ctype == "val*" then
+               if not value.mtype.is_c_primitive then

                        if can_be_primitive(value) and not compiler.modelbuilder.toolcontext.opt_no_tag_primitives.value then
                                var tag = extract_tag(value)
                                return "({tag}?type_info[{tag}]:{value}->type)"
                        if can_be_primitive(value) and not compiler.modelbuilder.toolcontext.opt_no_tag_primitives.value then
                                var tag = extract_tag(value)
                                return "({tag}?type_info[{tag}]:{value}->type)"

@@ -1354,7 +1355,7 @@ class SeparateCompilerVisitor
        end
        redef fun send(mmethod, arguments)
        do
        end
        redef fun send(mmethod, arguments)
        do

-               if arguments.first.mcasttype.ctype != "val*" then
+               if arguments.first.mcasttype.is_c_primitive then

                        # In order to shortcut the primitive, we need to find the most specific method
                        # Howverr, because of performance (no flattening), we always work on the realmainmodule
                        var m = self.compiler.mainmodule
                        # In order to shortcut the primitive, we need to find the most specific method
                        # Howverr, because of performance (no flattening), we always work on the realmainmodule
                        var m = self.compiler.mainmodule

@@ -1436,13 +1437,14 @@ class SeparateCompilerVisitor
                if compiler.modelbuilder.toolcontext.opt_invocation_metrics.value then add("count_invoke_by_tables++;")
 
                assert arguments.length == mmethod.intro.msignature.arity + 1 else debug("Invalid arity for {mmethod}. {arguments.length} arguments given.")
                if compiler.modelbuilder.toolcontext.opt_invocation_metrics.value then add("count_invoke_by_tables++;")
 
                assert arguments.length == mmethod.intro.msignature.arity + 1 else debug("Invalid arity for {mmethod}. {arguments.length} arguments given.")

-               var recv = arguments.first

 
                var res0 = before_send(mmethod, arguments)
 
                var runtime_function = mmethod.intro.virtual_runtime_function
                var msignature = runtime_function.called_signature
 
 
                var res0 = before_send(mmethod, arguments)
 
                var runtime_function = mmethod.intro.virtual_runtime_function
                var msignature = runtime_function.called_signature
 

+               adapt_signature(mmethod.intro, arguments)
+

                var res: nullable RuntimeVariable
                var ret = msignature.return_mtype
                if ret == null then
                var res: nullable RuntimeVariable
                var ret = msignature.return_mtype
                if ret == null then

@@ -1451,18 +1453,7 @@ class SeparateCompilerVisitor
                        res = self.new_var(ret)
                end
 
                        res = self.new_var(ret)
                end
 

-               var ss = new FlatBuffer
-
-               ss.append("{recv}")
-               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
-                       a = self.autobox(a, t)
-                       ss.append(", {a}")
-               end
+               var ss = arguments.join(", ")

 
                var const_color = mentity.const_color
                var ress
 
                var const_color = mentity.const_color
                var ress

@@ -1561,7 +1552,7 @@ class SeparateCompilerVisitor
 
        redef fun supercall(m: MMethodDef, recvtype: MClassType, arguments: Array[RuntimeVariable]): nullable RuntimeVariable
        do
 
        redef fun supercall(m: MMethodDef, recvtype: MClassType, arguments: Array[RuntimeVariable]): nullable RuntimeVariable
        do

-               if arguments.first.mcasttype.ctype != "val*" then
+               if arguments.first.mcasttype.is_c_primitive then

                        # In order to shortcut the primitive, we need to find the most specific method
                        # However, because of performance (no flattening), we always work on the realmainmodule
                        var main = self.compiler.mainmodule
                        # In order to shortcut the primitive, we need to find the most specific method
                        # However, because of performance (no flattening), we always work on the realmainmodule
                        var main = self.compiler.mainmodule

@@ -1612,7 +1603,7 @@ class SeparateCompilerVisitor
                        self.add("{res} = {recv}->attrs[{a.const_color}] != NULL; /* {a} on {recv.inspect}*/")
                else
 
                        self.add("{res} = {recv}->attrs[{a.const_color}] != NULL; /* {a} on {recv.inspect}*/")
                else
 

-                       if mtype.ctype == "val*" then
+                       if not mtype.is_c_primitive and not mtype.is_tagged then

                                self.add("{res} = {recv}->attrs[{a.const_color}].val != NULL; /* {a} on {recv.inspect} */")
                        else
                                self.add("{res} = 1; /* NOT YET IMPLEMENTED: isset of primitives: {a} on {recv.inspect} */")
                                self.add("{res} = {recv}->attrs[{a.const_color}].val != NULL; /* {a} on {recv.inspect} */")
                        else
                                self.add("{res} = 1; /* NOT YET IMPLEMENTED: isset of primitives: {a} on {recv.inspect} */")

@@ -1664,7 +1655,7 @@ class SeparateCompilerVisitor
                        self.add("{res} = {recv}->attrs[{a.const_color}].{ret.ctypename}; /* {a} on {recv.inspect} */")
 
                        # Check for Uninitialized attribute
                        self.add("{res} = {recv}->attrs[{a.const_color}].{ret.ctypename}; /* {a} on {recv.inspect} */")
 
                        # Check for Uninitialized attribute

-                       if ret.ctype == "val*" and not ret isa MNullableType and not self.compiler.modelbuilder.toolcontext.opt_no_check_attr_isset.value then
+                       if not ret.is_c_primitive and not ret isa MNullableType and not self.compiler.modelbuilder.toolcontext.opt_no_check_attr_isset.value then

                                self.add("if (unlikely({res} == NULL)) \{")
                                self.add_abort("Uninitialized attribute {a.name}")
                                self.add("\}")
                                self.add("if (unlikely({res} == NULL)) \{")
                                self.add_abort("Uninitialized attribute {a.name}")
                                self.add("\}")

@@ -1693,7 +1684,11 @@ class SeparateCompilerVisitor
                self.require_declaration(a.const_color)
                if self.compiler.modelbuilder.toolcontext.opt_no_union_attribute.value then
                        var attr = "{recv}->attrs[{a.const_color}]"
                self.require_declaration(a.const_color)
                if self.compiler.modelbuilder.toolcontext.opt_no_union_attribute.value then
                        var attr = "{recv}->attrs[{a.const_color}]"

-                       if mtype.ctype != "val*" then
+                       if mtype.is_tagged then
+                               # The attribute is not primitive, thus store it as tagged
+                               var tv = autobox(value, compiler.mainmodule.object_type)
+                               self.add("{attr} = {tv}; /* {a} on {recv.inspect} */")
+                       else if mtype.is_c_primitive 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
                                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

@@ -1845,15 +1840,15 @@ class SeparateCompilerVisitor
        do
                var res = self.new_var(bool_type)
                # Swap values to be symetric
        do
                var res = self.new_var(bool_type)
                # Swap values to be symetric

-               if value2.mtype.ctype != "val*" and value1.mtype.ctype == "val*" then
+               if value2.mtype.is_c_primitive and not value1.mtype.is_c_primitive then

                        var tmp = value1
                        value1 = value2
                        value2 = tmp
                end
                        var tmp = value1
                        value1 = value2
                        value2 = tmp
                end

-               if value1.mtype.ctype != "val*" then
+               if value1.mtype.is_c_primitive then

                        if value2.mtype == value1.mtype then
                                self.add("{res} = 1; /* is_same_type_test: compatible types {value1.mtype} vs. {value2.mtype} */")
                        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
+                       else if value2.mtype.is_c_primitive 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} = 0; /* is_same_type_test: incompatible types {value1.mtype} vs. {value2.mtype}*/")
                        else
                                var mtype1 = value1.mtype.as(MClassType)

@@ -1870,7 +1865,7 @@ class SeparateCompilerVisitor
        do
                var res = self.get_name("var_class_name")
                self.add_decl("const char* {res};")
        do
                var res = self.get_name("var_class_name")
                self.add_decl("const char* {res};")

-               if value.mtype.ctype == "val*" then
+               if not value.mtype.is_c_primitive then

                        self.add "{res} = {value} == NULL ? \"null\" : {type_info(value)}->name;"
                else if value.mtype isa MClassType and value.mtype.as(MClassType).mclass.kind == extern_kind and
                        value.mtype.as(MClassType).name != "NativeString" then
                        self.add "{res} = {value} == NULL ? \"null\" : {type_info(value)}->name;"
                else if value.mtype isa MClassType and value.mtype.as(MClassType).mclass.kind == extern_kind and
                        value.mtype.as(MClassType).name != "NativeString" then

@@ -1885,15 +1880,15 @@ class SeparateCompilerVisitor
        redef fun equal_test(value1, value2)
        do
                var res = self.new_var(bool_type)
        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
+               if value2.mtype.is_c_primitive and not value1.mtype.is_c_primitive then

                        var tmp = value1
                        value1 = value2
                        value2 = tmp
                end
                        var tmp = value1
                        value1 = value2
                        value2 = tmp
                end

-               if value1.mtype.ctype != "val*" then
+               if value1.mtype.is_c_primitive then

                        if value2.mtype == value1.mtype then
                                self.add("{res} = {value1} == {value2};")
                        if value2.mtype == value1.mtype then
                                self.add("{res} = {value1} == {value2};")

-                       else if value2.mtype.ctype != "val*" then
+                       else if value2.mtype.is_c_primitive then

                                self.add("{res} = 0; /* incompatible types {value1.mtype} vs. {value2.mtype}*/")
                        else if value1.mtype.is_tagged then
                                self.add("{res} = ({value2} != NULL) && ({self.autobox(value2, value1.mtype)} == {value1});")
                                self.add("{res} = 0; /* incompatible types {value1.mtype} vs. {value2.mtype}*/")
                        else if value1.mtype.is_tagged then
                                self.add("{res} = ({value2} != NULL) && ({self.autobox(value2, value1.mtype)} == {value1});")

@@ -1926,11 +1921,11 @@ class SeparateCompilerVisitor
 
                var incompatible = false
                var primitive
 
                var incompatible = false
                var primitive

-               if t1.ctype != "val*" then
+               if t1.is_c_primitive then

                        primitive = t1
                        if t1 == t2 then
                                # No need to compare class
                        primitive = t1
                        if t1 == t2 then
                                # No need to compare class

-                       else if t2.ctype != "val*" then
+                       else if t2.is_c_primitive then

                                incompatible = true
                        else if can_be_primitive(value2) then
                                if t1.is_tagged then
                                incompatible = true
                        else if can_be_primitive(value2) then
                                if t1.is_tagged then

@@ -1944,7 +1939,7 @@ class SeparateCompilerVisitor
                        else
                                incompatible = true
                        end
                        else
                                incompatible = true
                        end

-               else if t2.ctype != "val*" then
+               else if t2.is_c_primitive then

                        primitive = t2
                        if can_be_primitive(value1) then
                                if t2.is_tagged then
                        primitive = t2
                        if can_be_primitive(value1) then
                                if t2.is_tagged then

@@ -2002,10 +1997,10 @@ class SeparateCompilerVisitor
 
        fun can_be_primitive(value: RuntimeVariable): Bool
        do
 
        fun can_be_primitive(value: RuntimeVariable): Bool
        do

-               var t = value.mcasttype.as_notnullable
+               var t = value.mcasttype.undecorate

                if not t isa MClassType then return false
                var k = t.mclass.kind
                if not t isa MClassType then return false
                var k = t.mclass.kind

-               return k == interface_kind or t.ctype != "val*"
+               return k == interface_kind or t.is_c_primitive

        end
 
        fun maybe_null(value: RuntimeVariable): Bool
        end
 
        fun maybe_null(value: RuntimeVariable): Bool

@@ -2016,8 +2011,8 @@ class SeparateCompilerVisitor
 
        redef fun array_instance(array, elttype)
        do
 
        redef fun array_instance(array, elttype)
        do

-               var nclass = self.get_class("NativeArray")
-               var arrayclass = self.get_class("Array")
+               var nclass = mmodule.native_array_class
+               var arrayclass = mmodule.array_class

                var arraytype = arrayclass.get_mtype([elttype])
                var res = self.init_instance(arraytype)
                self.add("\{ /* {res} = array_instance Array[{elttype}] */")
                var arraytype = arrayclass.get_mtype([elttype])
                var res = self.init_instance(arraytype)
                self.add("\{ /* {res} = array_instance Array[{elttype}] */")

@@ -2034,10 +2029,11 @@ class SeparateCompilerVisitor
 
        redef fun native_array_instance(elttype: MType, length: RuntimeVariable): RuntimeVariable
        do
 
        redef fun native_array_instance(elttype: MType, length: RuntimeVariable): RuntimeVariable
        do

-               var mtype = self.get_class("NativeArray").get_mtype([elttype])
+               var mtype = mmodule.native_array_type(elttype)

                self.require_declaration("NEW_{mtype.mclass.c_name}")
                assert mtype isa MGenericType
                var compiler = self.compiler
                self.require_declaration("NEW_{mtype.mclass.c_name}")
                assert mtype isa MGenericType
                var compiler = self.compiler

+               length = autobox(length, compiler.mainmodule.int_type)

                if mtype.need_anchor then
                        hardening_live_open_type(mtype)
                        link_unresolved_type(self.frame.mpropdef.mclassdef, mtype)
                if mtype.need_anchor then
                        hardening_live_open_type(mtype)
                        link_unresolved_type(self.frame.mpropdef.mclassdef, mtype)

@@ -2054,7 +2050,7 @@ class SeparateCompilerVisitor
        redef fun native_array_def(pname, ret_type, arguments)
        do
                var elttype = arguments.first.mtype
        redef fun native_array_def(pname, ret_type, arguments)
        do
                var elttype = arguments.first.mtype

-               var nclass = self.get_class("NativeArray")
+               var nclass = mmodule.native_array_class

                var recv = "((struct instance_{nclass.c_name}*){arguments[0]})->values"
                if pname == "[]" then
                        # Because the objects are boxed, return the box to avoid unnecessary (or broken) unboxing/reboxing
                var recv = "((struct instance_{nclass.c_name}*){arguments[0]})->values"
                if pname == "[]" then
                        # Because the objects are boxed, return the box to avoid unnecessary (or broken) unboxing/reboxing

@@ -2075,12 +2071,20 @@ class SeparateCompilerVisitor
                end
        end
 
                end
        end
 

-       redef fun calloc_array(ret_type, arguments)
+       redef fun native_array_get(nat, i)

        do
        do

-               var mclass = self.get_class("ArrayCapable")
-               var ft = mclass.mparameters.first
-               var res = self.native_array_instance(ft, arguments[1])
-               self.ret(res)
+               var nclass = mmodule.native_array_class
+               var recv = "((struct instance_{nclass.c_name}*){nat})->values"
+               # Because the objects are boxed, return the box to avoid unnecessary (or broken) unboxing/reboxing
+               var res = self.new_expr("{recv}[{i}]", compiler.mainmodule.object_type)
+               return res
+       end
+
+       redef fun native_array_set(nat, i, val)
+       do
+               var nclass = mmodule.native_array_class
+               var recv = "((struct instance_{nclass.c_name}*){nat})->values"
+               self.add("{recv}[{i}]={val};")

        end
 
        fun link_unresolved_type(mclassdef: MClassDef, mtype: MType) do
        end
 
        fun link_unresolved_type(mclassdef: MClassDef, mtype: MType) do

@@ -2193,7 +2197,7 @@ class SeparateRuntimeFunction
                for i in [0..called_signature.arity[ do
                        var mtype = called_signature.mparameters[i].mtype
                        if i == called_signature.vararg_rank then
                for i in [0..called_signature.arity[ do
                        var mtype = called_signature.mparameters[i].mtype
                        if i == called_signature.vararg_rank then

-                               mtype = mmethoddef.mclassdef.mmodule.get_primitive_class("Array").get_mtype([mtype])
+                               mtype = mmethoddef.mclassdef.mmodule.array_type(mtype)

                        end
                        sig.append(", {mtype.ctype} p{i}")
                end
                        end
                        sig.append(", {mtype.ctype} p{i}")
                end

@@ -2232,7 +2236,7 @@ class SeparateRuntimeFunction
                for i in [0..msignature.arity[ do
                        var mtype = msignature.mparameters[i].mtype
                        if i == msignature.vararg_rank then
                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])
+                               mtype = v.mmodule.array_type(mtype)

                        end
                        comment.append(", {mtype}")
                        var argvar = new RuntimeVariable("p{i}", mtype, mtype)
                        end
                        comment.append(", {mtype}")
                        var argvar = new RuntimeVariable("p{i}", mtype, mtype)

@@ -2279,14 +2283,14 @@ class SeparateRuntimeFunction
                var selfvar = arguments.first
                var ret = called_signature.return_mtype
 
                var selfvar = arguments.first
                var ret = called_signature.return_mtype
 

-               if mmethoddef.is_intro and recv.ctype == "val*" then
+               if mmethoddef.is_intro and not recv.is_c_primitive then

                        var m = mmethoddef.mproperty
                        var n2 = "CALL_" + m.const_color
                        compiler.provide_declaration(n2, "{c_ret} {n2}{c_sig};")
                        var v2 = compiler.new_visitor
                        v2.add "{c_ret} {n2}{c_sig} \{"
                        v2.require_declaration(m.const_color)
                        var m = mmethoddef.mproperty
                        var n2 = "CALL_" + m.const_color
                        compiler.provide_declaration(n2, "{c_ret} {n2}{c_sig};")
                        var v2 = compiler.new_visitor
                        v2.add "{c_ret} {n2}{c_sig} \{"
                        v2.require_declaration(m.const_color)

-                       var call = "(({c_funptrtype})({selfvar}->class->vft[{m.const_color}]))({arguments.join(", ")});"
+                       var call = "(({c_funptrtype})({v2.class_info(selfvar)}->vft[{m.const_color}]))({arguments.join(", ")});"

                        if ret != null then
                                v2.add "return {call}"
                        else
                        if ret != null then
                                v2.add "return {call}"
                        else

@@ -2296,14 +2300,14 @@ class SeparateRuntimeFunction
                        v2.add "\}"
 
                end
                        v2.add "\}"
 
                end

-               if mmethoddef.has_supercall and recv.ctype == "val*" then
+               if mmethoddef.has_supercall and not recv.is_c_primitive then

                        var m = mmethoddef
                        var n2 = "CALL_" + m.const_color
                        compiler.provide_declaration(n2, "{c_ret} {n2}{c_sig};")
                        var v2 = compiler.new_visitor
                        v2.add "{c_ret} {n2}{c_sig} \{"
                        v2.require_declaration(m.const_color)
                        var m = mmethoddef
                        var n2 = "CALL_" + m.const_color
                        compiler.provide_declaration(n2, "{c_ret} {n2}{c_sig};")
                        var v2 = compiler.new_visitor
                        v2.add "{c_ret} {n2}{c_sig} \{"
                        v2.require_declaration(m.const_color)

-                       var call = "(({c_funptrtype})({selfvar}->class->vft[{m.const_color}]))({arguments.join(", ")});"
+                       var call = "(({c_funptrtype})({v2.class_info(selfvar)}->vft[{m.const_color}]))({arguments.join(", ")});"

                        if ret != null then
                                v2.add "return {call}"
                        else
                        if ret != null then
                                v2.add "return {call}"
                        else

@@ -2344,3 +2348,14 @@ redef class AMethPropdef
                return super
        end
 end
                return super
        end
 end

+
+redef class AAttrPropdef
+       redef fun init_expr(v, recv)
+       do
+               super
+               if is_lazy and v.compiler.modelbuilder.toolcontext.opt_no_union_attribute.value then
+                       var guard = self.mlazypropdef.mproperty
+                       v.write_attribute(guard, recv, v.bool_instance(false))
+               end
+       end
+end